Arduino Book

เรียนรู้และลองเล่น
Arduino เบื้องต้น
ครูประภาส สุวรรณเพชร
ก
เรียนรู้และลองเล่น Arduino เบื้องต้ น

โดย ครู ประภาส สุ วรรณเพชร
สงวนลิขสิ ทธิ์ สำหรับกำรพิมพ์เพื่อจำหน่ำย © โดยครู ประภำส สุ วรรณเพชร

ไม่สงวนลิขสิ ทธิ์ สำหรับกำรพิมพ์เพื่อเป็ นวิทยำทำน
หากพบเจอข้ อผิดพลาดใด ๆ ในหนังสื อเล่มนี้

กรุ ณำแจ้ง praphas@hotmail.com
จักเป็ นพระคุณอย่ำงสู ง ทั้งนี้เพื่อปรับปรุ งแก้ไขให้สมบูรณ์ต่อไป
หนังสื อเล่มนี้ จดั ไว้สำหรับกำรพิมพ์สองด้ำนหน้ำกระดำษ
ครู ประภำส สุ วรรณเพชร

แผนกวิชำช่ำงอิเล็กทรอนิกส์
วิทยำลัยเทคเทคนิคชัยภูมิ
www.praphas.com
praphas@hotmail.com
ก
คำนำ
ปั จจุ บ นั ไมโครคอนโทรลเลอร์ มี ก ารนามาใช้ง านกันแพร่ หลายมากขึ้ น โดยมี ก ารฝั ง ตัวของ
ไมโครคอนโทรลเลอร์ อยูใ่ นเครื่ องใช้ไฟฟ้าหลาย ๆ ประเภท เช่น เครื่ องซักผ้าแบบอัตโนมัติ เตาอบไฟฟ้า
เตาไมโครเวฟ เครื่ องปรั บ อากาศที่ ส ามารถก าหนดอุ ณหภู มิ ไ ด้และอื่ น ๆ อี ก มากมาย Arduino เป็ น
ไมโครคอนโทรลเลอร์ แพลทฟอร์ มหนึ่งที่ได้รับความนิยมมาก อันเนื่องจากเป็ นแพลทฟอร์ มแบบเปิ ดทั้ง
ฮาร์ ดแวร์ แ ละซอฟต์แ วร์ ก ารใช้ง านง่ า ยไม่ ซับ ซ้ อ นมี ต้น ทุ นในการสร้ างวงจรต่ า ซึ่ ง ในการใช้ง าน
ไมโครคอนโทรลเลอร์ จะต้องประกอบด้วยองค์ประกอบ 2 อย่างคือ ตัวเครื่ องหรื อที่เรี ยกว่า ฮาร์ ดแวร์
(Hardware) และโปรแกรมหรื อชุดคาสั่งที่เรี ยกว่า ซอฟต์แวร์ (Software) ที่ใช้สั่งให้ไมโครคอนโทรลเลอร์
ทาตามความต้องการของผูอ้ อกแบบ หนังสื อเล่มนี้ อธิ บายถึ งหลักการออกแบบฮาร์ ตแวร์ และการเขี ยน
ซอฟท์แวร์เพื่อใช้ควบคุม
เอกสารเล่มนี้ ขา้ พเจ้าได้เรี ยบเรี ยงขึ้ นจากประสบการณ์ ที่สอนนักศึกษาเป็ นเวลากว่า 25 ปี ได้

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

มากที่ สุ ด หากมี คุ ณ ความดี ป ระการใดข้า พเจ้า ขอมอบแด่ บิ ด ามารดาผู ซ้ ่ ึ งเลี้ ย งดู แ ละอบรมสั่ ง สอน
ครู อาจารย์ที่ประสิ ทธิ์ ประศาสตร์ วชิ าความรู ้และภรรยาบุตรธิดาที่ให้กาลังใจในการจัดทาเอกสารเล่มนี้
ประภาส สุ วรรณเพชร
ผูเ้ รี ยบเรี ยง
ข
สำรบัญ
หน้า
คานา ก
สารบัญ ข
บทที่ 1 ควำมรู้ เบื้องต้ นเกีย่ วกับไมโครคอนโทรลเลอร์ 1
1.1 ระบบตัวเลขและรหัส 2
1.2 ดิจิทลั พื้นฐาน 9
1.3 โครงสร้างพื้นฐานของระบบคอมพิวเตอร์ 12
1.4 ไมโครคอนโทรลเลอร์ Arduino 14
บทที่ 2 กำรเขียนโปรแกรมภำษำซีสำหรับไมโครคอนโทรลเลอร์ 17
2.1 ขั้นตอนในการพัฒนาโปรแกรม 18
2.2 ภาษาซีสาหรับไมโครคอนโทรลเลอร์ 21
2.3 การสร้างฟังก์ชนั่ รองขึ้นใช้เอง 33
บทที่ 3 เครื่ องมือช่ วยพัฒนำงำนไมโครคอนโทรลเลอร์ 45
3.1 เครื่ องมือแปลงภาษาซีเป็ นภาษาเครื่ อง 46
3.2 การติดตั้งไดร์ เวอร์ USB 50
3.2 เครื่ องมือจาลองการทางาน 51
บทที่ 4 ใบงำนกำรทดลอง 55
ใบงานที่ 4.1 การทดสอบบอร์ ดเบื้องต้น 57
ใบงานที่ 4.2 การเขียนโปรแกรมสื่ อสารทางพอร์ตอนุกรม 63
ใบงานที่ 4.3 การเขียนโปรแกรมใช้งานพอร์ ตทาหน้าที่เอาท์พุทพอร์ ตเบื้องต้น 71
ใบงานที่ 4.4 การเขียนโปรแกรมรับค่าจากพอร์ ตดิจิทลั 79
ใบงานที่ 4.5 การเขียนโปรแกรมอ่านค่าจากพอร์ ตแอนาลอกและการใช้ PWM 89
ใบงานที่ 4.6 การเขียนโปรแกรมรับสวิตช์ทางพอร์ ตแอนาลอก 99
ใบงานที่ 4.7 การเขียนโปรแกรมวัดอุณหภูมิดว้ ยเทอร์มิสเตอร์ชนิด NTC 109
ใบงานที่ 4.8 การเขียนโปรแกรมวัดอุณหภูมิและความชื้นด้วยโมดูล DHT22 119
ใบงานที่ 4.9 การเขียนโปรแกรมใช้งานไอซีวดั อุณหภูมิ DS18B20 127
ใบงานที่ 4.10 การเขียนโปรแกรมวัดระยะด้วยโมดูลอัลตร้าโซนิค 139
ใบงานที่ 4.11 การเขียนโปรแกรมควมคุมดีซีมอเตอร์ 151
ใบงานที่ 4.12 การเขียนโปรแกรมควมคุมสเต็ปเปอร์มอเตอร์ 163
ค
สำรบัญ (ต่ อ)
หน้า
ใบงานที่ 4.13 การเขียนโปรแกรมควมคุมเซอร์ โวมอเตอร์ 173
ใบงานที่ 4.14 การเขียนโปรแกรมใช้งานอินเตอร์ รัพท์ 181
ใบงานที่ 4.15 การเขียนโปรแกรมใช้งานหน่วยความจา EEPROM 193
ใบงานที่ 4.16 การเขียนโปรแกรมใช้งานคียแ์ พด 203
ใบงานที่ 4.17 การเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ 4 บิต 213
ใบงานที่ 4.18 การเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ I2C 221
ใบงานที่ 4.19 การเขียนโปรแกรมแสดงผลด้วยโมดูลตัวเลข MAX7219 231
ใบงานที่ 4.20 การเขียนโปรแกรมแสดงผลด้วยจอ OLED 128×64 245
ใบงานที่ 4.21 การเขียนโปรแกรมแสดงผลรู ปภาพด้วยจอ OLED 128×64 263
ใบงานที่ 4.22 การประยุกต์การแสดงผลที่ LCD 4 bit กับเซนเซอร์ ต่าง ๆ 275
ใบงานที่ 4.23 การประยุกต์การแสดงผลที่ LCD I2C กับเซนเซอร์ ต่าง ๆ 289
ใบงานที่ 4.24 การประยุกต์การแสดงผลด้วยโมดูล MAX7219 กับเซนเซอร์ ต่าง ๆ 303
ใบงานที่ 4.25 การประยุกต์การแสดงผลที่ OLED กับเซนเซอร์ ต่าง ๆ 317
บรรณานุกรม 329
ภาคผนวก 330
บทที่ 1 ความรู ้เบื้องต้นเกี่ยวกับไมโครคอนโทรลเลอร์  1
บทที่ 1
ความรู้ เบื้องต้ นเกีย่ วกับไมโครคอนโทรลเลอร์
หัวข้อเรื่ อง
1.1 ระบบตัวเลขและรหัส
1.2 ดิจิทลั พื้นฐาน
1.3 โครงสร้างพื้นฐานของระบบคอมพิวเตอร์
1.4 ไมโครคอนโทรลเลอร์ Arduino
สาระสาคัญ
ความรู ้ เบื้ องต้นเกี่ ย วกับ ไมโครคอนโทรลเลอร์ ใ นบทนี้ กล่ า วถึ ง ระบบตัวเลขที่ เกี่ ยวข้องกับ
ไมโครคอนโทรลเลอร์ มีหวั ข้อความรู ้ดา้ นดิจิทลั พื้นฐานที่มีใช้งานในไมโครคอนโทรลเลอร์ และความรู ้
ทัว่ ไปของไมโครคอนโทรลเลอร์ Arduino
สมรรถนะประจาหน่วยการเรี ยนรู ้
แสดงความรู ้เกี่ยวกับไมโครคอนโทรลเลอร์ Arduino
จุดประสงค์การเรี ยนรู ้
จุดประสงค์ ทวั่ ไป
1. เพื่อให้มีความรู ้เกี่ยวกับระบบตัวเลขและดิจิทลั พื้นฐาน
2. เพื่อให้มีความรู ้เกี่ยวกับโครงสร้างพื้นฐานของระบบคอมพิวเตอร์
3. เพื่อให้มีความรู ้เกี่ยวกับไมโครคอนโทรลเลอร์ Arduino
จุดประสงค์ เชิ งพฤติกรรม
1. บอกวิธีการแปลงเลขฐานในระบบตัวเลขและดิจิทลั พื้นฐานได้
2. บอกเกี่ยวกับโครงสร้างพื้นฐานของระบบคอมพิวเตอร์ ได้
3. บอกเกี่ยวกับไมโครคอนโทรลเลอร์ Arduino ได้
4. ทาแบบฝึ กหัดเสร็ จทันเวลาและทาแบบทดสอบผ่านเกณฑ์ที่กาหนด
2 เรี ยนรู ้และลองเล่น Arduino เบื้องต้น [ครู ประภาส สุวรรณเพชร]
ความรู้ เบื้องต้ นเกีย่ วกับไมโครคอนโทรลเลอร์

ไมโครคอนโทรลเลอร์ ( Microcontroller) มาจากคา 2 คา คาหนึ่ งคือ ไมโคร (Micro) หมายถึง
ขนาดเล็ ก และค าว่ า คอนโทรลเลอร์ (Controller) หมายถึ ง ตัว ควบคุ ม หรื อ อุ ป กรณ์ ค วบคุ ม ดัง นั้น
ไมโครคอนโทรลเลอร์ จึ งหมายถึ งอุ ปกรณ์ ควบคุ มขนาดเล็ก แต่ในตัวอุ ปกรณ์ ควบคุ มขนาดเล็กนี้ ได้
บรรจุ ค วามสามารถที่ ค ล้า ยคลึ ง กับ ระบบคอมพิ ว เตอร์ ที่ ค นโดยส่ ว นใหญ่ ค ้น เคย กล่ า วคื อ ภายใน
ไมโครคอนโทรลเลอร์ ได้รวมเอาหน่วยประมวลผลหลัก หน่วยความจา และพอร์ ต ซึ่ งเป็ นส่ วนประกอบ
หลักสาคัญของระบบคอมพิวเตอร์ เข้าไว้ดว้ ยกันโดยทาการบรรจุเข้าไว้ในตัวถังเดียวกัน ความแตกต่าง
ของไมโครคอนโทรลเลอร์ กบั ไมโครโปรเซสเซอร์ คือไมโครคอนโทรลเลอร์ น้ นั มีความสมบูรณ์ภายใน
ตัวของมันเอง คื อ มี ส่ วนประกอบต่ า ง ๆ ครบถ้วน ส่ วนไมโครโปรเซสเซอร์ น้ ันต้องท างานร่ วมกับ
อุปกรณ์ขา้ งเคียงที่เชื่อมต่อจากภายนอก เช่น หน่วยความจา (Memory) หน่วยอินพุตเอาต์พุต (I/O) ฯลฯ 1
เพื่อให้เข้าใจการทางานของไมโครคอนโทรลเลอร์ พร้ อมทั้งวงจรต่อพ่วงแบบต่าง ๆ สิ่ งแรกที่
จะต้องทาความเข้าใจก่อนที่จะเข้าเรื่ องไมโครคอนโทรลเลอร์ จะต้องเข้าใจเกี่ยวกับระบบตัวเลข ระบบ
การเข้ารหัส ระบบลอจิก เกต โดยระบบทั้งหมดเป็ นการทางานภายในคอมพิวเตอร์ เนื้ อหาบทนี้ จะเป็ น
พื้นฐานในการเรี ยนรู ้ และทาความเข้าใจเกี่ยวกับไมโครคอนโทรลเลอร์ ในบทถัดไป
1.1 ระบบตัวเลขและรหัส
แนวคิ ดเกี่ ยวกับจานวนและการนับมี มาแต่โบราณ มนุ ษย์สามารถนับจานวนสิ่ งต่าง ๆ โดยมี
ความคิดว่าเมื่อเพิ่มสิ่ งใดสิ่ งใดก็จะได้สิ่งนั้น “มากขึ้น” และถ้าเอาสิ่ งนั้นออกไปจะทาให้สิ่งนั้น “ลดลง”
ต่อเมื่อสังคมเจริ ญขึ้ นก็ใช้วิธีการจับคู่สิ่งนั้น เช่ น อาจใช้นิ้วมือแทนสิ่ งเหล่านั้น เช่ น หนึ่ งนิ้ วแทนสัตว์
หนึ่งตัวและอาจใช้กอ้ นหิ นบันทึกจานวนสิ่ งนั้น หรื ออาจใช้ขีดเขียนบนพื้นดิน หรื อสลักบนต้นไม้ ต่อมา
จึงใช้สัญลักษณ์แทนจานวนขึ้น และพบว่าการนับและการเขียนในสมัยโบราณนั้นจะไม่มี “ศูนย์”
มีหลักฐานยืนยันเมื่อปี ค.ศ. ที่ 9 ใช้เรี ยกเป็ นตัวเลขอาระบิกเป็ นชื่ อที่เรี ยกตัวเลขที่ประดิษฐ์ข้ ึน
ขึ้นในประเทศอินเดียยุคโบราณโดยนักคณิ ตศาสตร์ ชาวอินเดียนประมาณ 500 ปี ก่อนคริ สตศักราชจากนั้น
จึงไปถ่ายทอดไปยังประเทศในแถบยุโรปในยุคกลางทั้ง ๆ ที่เริ่ มต้นที่ประเทศอินเดี ย แต่เริ่ มรู ้ จกั ในฝั่ ง
ตะวันตกในชื่ อว่า ตัวเลขอาระบิก ทั้งนี้เนื่องจากในยุโรปได้ใช้ตาราของอาหรับ (Arabic texts) เช่น “ The
calculation with Hindu numerals” เป็ นต้น ทาให้ชาวยุโรปพากันเรี ยกตัวเลขนี้ ว่าตัวเลขอาระบิกและใน
ปั จจุบนั จึงเรี ย กตัวเลขนี้ ว่าตัวเลขฮิ นดู อาระบิ กด้วยตัวเลขอาระบิ กนี้ เรี ยกในภาษาอาระบิ กว่า "Hindu
numerals"," ‫ " أرقام هندية‬ต่ อ มาเรี ยกว่ า Hindu-Arabic numerals หรื อ Indian numerals อัน เป็ น
สัญลักษณ์ที่ใช้แทนจานวนกันทัว่ โลก
Mechanical Engineering, เอกสารประกอบการอบรมค่ ายหุ่นยนต์ ปลาครั้งที่ 2, หน้า 1.

1
ตัวเลขที่ใช้อยูใ่ นปั จจุบนั ซึ่ งเรี ยกว่าตัวเลขฮินดูอาระบิกนี้ ใช้แทนด้วยตัวเลข 10 ตัวคือ 1, 2, 3, 4,

5, 6, 7, 8, 9 และ 0 ตัวเลขเหล่ านี้ ได้มีข้ ึ นในยุโรปในศตวรรษที่ 12 โดย Leonardo Pissano ซึ่ งเป็ นนัก
คณิ ตศาสตร์ ชาวอิตาเลียน เขาได้รับการศึกษาจากประเทศในแถบแอฟริ กาเหนือแล้วนาความรู ้กลับมาใช้
ในประเทศอิตาลี ระบบตัวเลขฮินดู เป็ นระบบที่มีค่าประจาตาแหน่ งค่าของตัวเลขขึ้นกับตาแหน่ งของ
ตัวเลขนั้น เช่น “2” ใน 205 มีค่าเป็ น 10 เท่าของ “2” ใน 25 ดังนั้นจึงต้องมี “0” เพื่อบอกตาแหน่งหรื อหลัก
สิ บ ใน“205” ด้วย การค้นพบตัวเลข 0 เกิดขึ้นหลังจากมีสัญลักษณ์แทนจานวนเต็ม 9 จานวนแล้วตัวเลข 0
ใช้แทนตาแหน่งว่างเปล่า เรี ยกว่า “ตัวรั้งตาแหน่ง” (Place holder)2
จากความก้าวหน้าทางเทคโนโลยีได้มีการพัฒนาเครื่ องคอมพิวเตอร์ ข้ ึ นมาใช้งาน โดยเครื่ อง
คอมพิ วเตอร์ เป็ นเครื่ องใช้ไ ฟฟ้ า ซึ่ ง ถู ก ออกแบบมาเพื่ อที่ จะรั บรู ้ ส ภาวะเพีย งสองสภาวะเท่ านั้น เพื่ อ
ป้ อ งกัน การผิ ด พลาดของข้อ มู ล คื อ สภาวะมี แ รงดัน ไฟฟ้ า โดยเรี ยกว่ า ลอจิ ก 1 และสภาวะไม่ มี
แรงดันไฟฟ้าโดยเรี ยกว่าลอจิก 0 ในระบบคอมพิวเตอร์ที่มีความเร็ วต่าแรงดันไฟฟ้าสาหรับลอจิก 1 จะมี
ค่าเท่ากับ 5 โวลต์และแรงดันไฟฟ้ าสาหรับลอจิก 0 จะมีค่าเท่ากับ 0 โวลต์ แต่สาหรับคอมพิวเตอร์ ที่มี
ความเร็ วสู งค่าระดับแรงดันลอจิก 1 จะลดลงเพื่อลดความร้อนที่เกิดขึ้นกับตัวประมวลผลกลาง
ดังนั้นการประมวลผลต่าง ๆ ของคอมพิวเตอร์ จึงใช้งานในระบบตัวเลขฐาน 2 หรื อที่ เรี ยกว่า
เลขไบนารี่ (Binary) ตัวเลขที่ใช้ระบบเลขฐาน 10 คือ 0, 1, 2, … 9 และในระบบเลขฐาน 2 มีเพียงเลข 0
กับ 1 เท่านั้น
การแปลงเลขฐาน 10 เป็ นเลขใด ๆ

ในการเขียนโปรแกรมคอมพิวเตอร์จาเป็ นต้องใช้เลขฐานหลัก ๆ 3 เลขฐานได้แก่ เลขฐาน 10 เลข
ฐาน 2 และเลขฐาน 16 ซึ่ งในแต่ละฐานมีความสัมพันธ์กนั จาเป็ นจะต้องมีความรู ้ในการแปลงเลขฐานเพื่อ
นาไปใช้ประโยชน์ในการเขียนโปรแกรมคอมพิวเตอร์
การแปลงเลขฐาน 10 ให้เป็ นเลขฐานใด ๆ นั้นทาได้โดยการหารเลขฐาน 10 ที่ตอ้ งการแปลงด้วย
ตัว เลขของเลขฐานที่ ต้ อ งการแปลงและเก็ บ ค่ า ผลลั พ ธ์ โดยเศษของการหารครั้ งแรกจะเป็ น
เลขฐานที่ตอ้ งการแปลงในบิตต่าสุ ด (LSB: Least significant bit) ส่ วนผลหารจะไปหารครั้งถัดไปด้วยเลข
ฐานที่ตอ้ งการแปลง เศษของการหารในครั้งนี้ จะเป็ นเลขฐานที่ตอ้ งการแปลงในบิตถัดขึ้นมา ส่ วนผลลัพธ์
ก็นาไปหารด้วยเลขฐานที่ตอ้ งการแปลงทาอย่างนี้ไปจนกระทัง่ ผลหารมีค่าเป็ น 0
รศ. รัตนพร บ่อคา, ประวัตขิ องจานวนและตัวเลข, วารสารวิทยาศาสตร์ ฉบับที่ 1-2, หน้า 48.
2
ตัวอย่าง การแปลงเลขฐาน 10 เป็ นเลขฐาน 2

โจทย์ จงแปลงค่า 4510 เป็ นเลขฐาน 2
วิธีทา
ผลลัพธ์ เศษ
45/2 = 22 1 บิตค่าต่าสุ ด (LSB: Least significant bit)
22/2 = 11 0
11/2 = 5 1
5/2 = 2 1
2/2 = 1 0
1/2 = 0 1 บิตค่าสู งสุ ด (MSB: Most significant bit)
คาตอบ 4510 = 1011012

วิธีทา
15/3 = 5 0
5/3 = 1 2
คาตอบ 2510 = 12003

วิธีทา
11/4 = 2 3
คาตอบ 2510 = 2314
การแปลงเลขฐานใด ๆ เป็ นเลขฐาน 10

การแปลงเลขฐานใด ๆ ให้เป็ นเลขฐาน 10 ต้องทาความเข้าใจเกี่ยวกับน้ าหนักของตัวเลขที่อยูใ่ น
ตาแหน่ งต่าง ๆ ก่อน น้ าหนักของตัวเลขที่อยู่ขวาสุ ด (LSB: Least significant bit) จะมีค่าเท่ากับเลขฐาน
นั้น ๆ ยกกาลังศูนย์และเลขตาแหน่ งถัดมาจะมีน้ าหนักเท่ากับเลขฐานนั้น ๆ ยกกาลังหนึ่ ง เป็ นเช่ นนี้ ไป
เรื่ อย ๆ ครบทุกหลัก สาหรับการหาค่าเลขฐานใด ๆ ให้เป็ นเลขฐานสิ บจะหาได้จากการรวมกันของผลคูณ
ในตัวเลขในตาแหน่งต่าง ๆ กับน้ าหนักของตัวเลขในตาแหน่งนั้น ๆ ดังตัวอย่าง

โจทย์ จงแปลงเลขฐาน 8 ของเลข 765438 ให้เป็ นเลขฐาน 10
วิธีทา
น้ าหนัก 84 83 82 81 80
เลข 7 6 5 4 3
ผลคูณ 7×84=28672 6×83=3072 5×82=320 4×81=32 3×80=3
765438 = 28672+3072+320+32+3 = 3209910

วิธีทา
น้ าหนัก 54 53 52 51 50
เลข 4 3 4 2 1
ผลคูณ 4×54=2500 3×53=375 4×52=100 2×51=10 1×50=1
434215 = 2500+375+100+10+1 = 298610

วิธีทา
น้ าหนัก 24 23 22 21 20
เลข 1 1 0 1 0
ผลคูณ 1×24=16 1×23=8 0×22=0 1×21=2 0×20=0
110102 = 16+8+0+2+0 = 2610
หากคานวณจากน้ าหนักในแต่ละตาแหน่งก่อนจะทาให้การหาค่าง่ายขึ้น ดังตัวอย่าง

วิธีทา
54 53 52 51 50
น้ าหนัก
625 125 25 5 1
เลข 4 3 4 2 1
ผลคูณ 4×625=2500 3×125=375 4×25=100 2×5=10 1×1=1
434215 = 2500+375+100+10+1 = 298610
วิธีทา
น้ าหนัก 24=16 23=8 22=4 21=2 20=1
เลข 1 1 0 1 0
ผลคูณ 1×16=16 1×8=8 0×4=0 1×2=2 0×1=0
110102 = 16+8+0+2+0 = 2610
ระบบเลขฐาน 16
ระบบเลขฐาน 16 (HEX: Hexadecimal) เป็ นเลข ตารางที่ 1-1 ความสัมพันธ์ของเลขฐาน
ที่ถูกเรี ยกใช้ในระบบคอมพิวเตอร์ซ่ ึงใช้แทนตัวเลขที่เป็ น
เลขฐาน 10 เลขฐาน 2 เลขฐาน 16
เลขฐาน 2 เพื่อให้ง่ายต่อการใช้งานเนื่ องจากเลขฐาน 2 มี 0 0000 0
แค่ เลข 0 และ 1 เท่ า นั้น ดัง เช่ น 1000100101102 แต่ เมื่ อ 1
2
0001
0010
1
2
เขียนเป็ นเลขฐาน 16 จะได้เพียง 89616 ในระบบเลขฐาน 3 0011 3
4 0100 4
2 ที่มีเพียงเลข 2 ตัวคือ 0 กับ 1 ในระบบเลขฐาน 10 มีเลข 5 0101 5
10 ตัวคือ 0, 1, 2, … 9 และในระบบเลขฐาน 16 มีตวั เลข 6
7
0110
0111
6
7
16 ตัว โดย 10 เลขแรกใช้เลขเดียวกับเลขฐาน 10 คือ 0 ถึง 8 1000 8
9 1001 9
9 ส่ วนที่เหลื ออีก 6 ตัว จะใช้ตวั อักษรภาษาอังกฤษแทน 10 1010 A
11 1011 B
คือ A, B, C, D, E, Cและ F ดังตารางที่ 1-1 12 1100 C
13 1101 D
14 1110 E
15 1111 F
การแปลงเลขฐานระหว่างเลขฐาน 2 กับเลขฐาน 16
ในการแปลงเลขฐาน 2 ให้เป็ นเลขฐาน 16 สามารถทาได้โดยการแบ่งกลุ่มตัวเลขของเลขฐาน 2
เริ่ มจากขวาไปซ้ายเป็ นกลุ่ม ๆ ละ 4 บิต และใช้จากตารางแสดงความสัมพันธ์ของเลขฐานในการแปลง
เลขฐานได้โดยตรงดังตัวอย่าง
ตัวอย่าง การแปลงเลขฐาน 2 ให้เป็ นเลขฐาน 16 โดยการแบ่งกลุ่มตัวเลข

วิธีทา แบ่งกลุ่มตัวเลขของเลขฐาน 2 เริ่ มจากขวาไปซ้ายเป็ นกลุ่ม ๆ ละ 4 บิต
1001 1111 0101 จากโจทย์
9 F 5
คาตอบ 1001111101012 = 9F5H
ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 2 โดยการแบ่งกลุ่มตัวเลข

โจทย์ จงแปลงค่า A72B16 เป็ นเลขฐาน 2
วิธีทา
A 7 2 B จากโจทย์
1010 0111 0010 1011
คาตอบ A72B16 = 10100111001010112
การแปลงเลขฐาน 10 เป็ นเลขฐาน 16

ในการแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 สามารถทาได้ 2 แนวทางคือ
1. แปลงเลขฐาน 10 ให้เป็ นเลขฐาน 2 ก่อนใช้วิธีการกระจายตามน้ าหนักของแต่ละบิตแล้วทาการ
แปลงเลขฐาน 2 ให้เป็ นเลขฐาน 16 ดังตัวอย่าง
ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 โดยการแปลงเป็ นเลขฐาน 2 ก่อน

วิธีทา น้ าหนักบิตฐาน 2 32 16 8 4 2 1
4510 กระจายได้ 1 0 1 1 0 1
คาตอบ 4510 = 32+0+8+4+0+1 = 1011012 = 0010 11012 = 2DH
ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16

วิธีทา
น้ าหนักบิต 1024 512 256 128 64 32 16 8 4 2 1
171410 1 1 0 1 0 1 1 0 0 1 0
คาตอบ 171410 = 110101100102 = 0110 1011 00102 = 6B216
2. แปลงโดยตรงทาได้โดยการหารเช่นเดียวกับการแปลงเลขฐาน 2 เป็ นเลขฐาน 10 ต่างตรงที่ใช้ 16

เป็ นตัวหาร ดังตัวอย่าง
ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 โดยการหาร

โจทย์ แปลงค่า 4510 เป็ นเลขฐาน 16
วิธีทา ผลหาร เศษ
45/16 2 13 =D
2/16 0 2 =2
คาตอบ 4510 =2D16
ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 โดยการหาร

โจทย์ แปลงค่า 23410 เป็ นเลขฐาน 16
วิธีทา ผลหาร เศษ
234/16 14 10 =A
14/16 0 14 =E
คาตอบ 23410 =EA16
การแปลงเลขฐาน 16 เป็ นเลขฐาน 10
ในการแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 สามารถทาได้ 2 แนวทางคือ

1. แปลงเลขฐาน 16 ให้เป็ นเลขฐาน 2 ก่อนแล้วทาการแปลงจากเลขฐาน 2 ที่ได้ให้เป็ นเลขฐาน 10
อีกครั้ง ดังตัวอย่าง
ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 โดยการแปลงเป็ นเลขฐาน 2 ก่อน

โจทย์ จงแปลงค่า 6B216 เป็ นเลขฐาน 10
วิธีทา
จากโจทย์ 6 B 2
ฐาน2 110 1011 0010
น้ าหนักฐาน 2 1024 512 256 128 64 32 16 8 4 2 1
1 1 0 1 0 1 1 0 0 1 0
คาตอบ (1024+512+0+128+32+16+0+0+2+0) = 171410
2. แปลงโดยตรงโดยรวมจากน้ าหนักของแต่ละหลักดังตัวอย่าง
ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 โดยรวมจากน้ าหนักในแต่ละหลัก
โจทย์ จงแปลงค่า 6B216 เป็ นเลขฐาน 10
วิธีทา
น้ าหนักฐาน 16 162 161 160
6 B(11) 2
6B216 = (6×16 )+(11×161)+(2×160)
2
= 1536+176+2
คาตอบ = 171410
ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 โดยรวมจากน้ าหนักในแต่ละหลัก

โจทย์ จงแปลงค่า ABC16 เป็ นเลขฐาน 10
วิธีทา
น้ าหนักฐาน 16 162 161 160
A(10) B(11) C(12)
ABC16 = (10×162)+(11×161)+(12×160)
= 2560+176+12
คาตอบ = 274810
1.2 ดิจิทลั พืน้ ฐาน

ดิจิทลั (Digital) เป็ นการอธิ บายเทคโนโลยี อิเล็กทรอนิกส์ ที่ใช้สร้าง เก็บ และประมวลข้อมูลใน
ลักษณะ 2 สถานะที่เรี ยกว่าลอจิก คือ บวกแสดงด้วยลอจิก 1 และไม่บวกแสดงด้วยลอจิก 0 ดังนั้นข้อมูล
ส่ งผ่านหรื อเก็บด้วยเทคโนโลยีดิจิทลั เป็ นการแสดงด้วยลอจิก 0 และ 1 แต่ละค่าของตาแหน่ งสถานะ
10  เรี ยนรู ้และลองเล่น Arduino เบื้องต้น [ครู ประภาส สุวรรณเพชร]
เหล่านี้เป็ นการอ้างแบบ Binary digital ดิจิทลั มีความเกี่ยวข้องกับไมโครคอนโทรลเลอร์ ท้ งั ฮาร์ ดแวร์ และ

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

ลอจิก 1 ก็มีขนาดแรงดันที่ต่าลงไปด้วย โดยค่าลอจิก 1 จะเป็ นค่าใกล้เคียงกับแรงดันไฟเลี้ยงในวงจร
ลอจิกเกตของเลขฐาน 2
ระบบเลขฐาน 2 สามารถนาลอจิกผ่านวงจรต่าง ๆ เพื่อให้ได้ลอจิกที่เปลี่ยนไป โดยวงจรดังกล่าว
เรี ยกว่าวงจรลอจิกเกตโดยมีวงจรต่าง ๆ ดังนี้
1. แอนด์เกต (AND gate)
2. ออร์ เกต (OR gate)
3. เอ็กซ์คลูซีฟออร์ เกต (XOR gate)
4. แนนด์เกต (NAND gate)
5. นอร์ เกต (NOR gate)
6. น็อตเกต (NOT gate)
แอนด์เกต (AND gate)

แอนด์เกตเป็ นวงจรที่มีอินพุตตั้งแต่ 2
แอนเกต (AND Gate)
อินพุตขึ้นไป เมื่อนาค่าลอจิกมาผ่านวงจรแล้ว
อินพุต เอาต์พุต
ให้ค่ า ลอจิ ก ทางเอาต์พุต ที่ มีค วามสัมพันธ์ กบั
A B Q A
อิ นพุ ตคื อ เมื่ ออิ น พุ ตทุ ก อิ น พุ ตมี ล อจิ ก เป็ น 1
0 0 0 Q
จะส่ งผลให้ลอจิกทางเอาต์พุตเป็ นลอจิก 1 แต่ B
0 1 0
ถ้าหากอินพุตมีค่าลอจิ ก 0 ในอินพุตใดอิน พุต
1 0 0
หนึ่งหรื อทั้งหมดจะส่ งผลให้ลอจิกทางเอาต์พุต
1 1 1
เป็ นลอจิก 0
ออร์เกต (OR gate)

ออร์ เ กตเป็ นวงจรที่ มี อิ น พุ ต ตั้ง แต่ 2
ออร์ เกต (OR Gate)
อินพุตขึ้นไป เมื่อนาค่าลอจิกมาผ่านวงจรแล้ว
ให้ค่ า ลอจิ ก ทางเอาต์พุต ที่ มีค วามสัมพันธ์ กบั
A B Q
อิ น พุ ต คื อ เมื่ อ อิ น พุ ต ใดอิ น พุ ต หนึ่ งหรื อ ทุ ก A
0 0 0 Q
อิ น พุ ต มี ล อจิ ก เป็ น 1 จะส่ ง ผลให้ ล อจิ ก ทาง
0 1 1 B
เอาต์พุตเป็ นลอจิก 1 หากทุกอินพุตมีค่าลอจิก 0
1 0 1
จะส่ งผลให้เอาต์พุตมีลอจิก 0
1 1 1
เอ็กซ์คลูซีฟออร์เกต (XOR gate)

เอ็กคลูซีฟออร์ เกตเป็ นวงจรที่มีอินพุต
เอ็กซ์คลูซีฟออร์ เกต
ตั้ง แต่ 2 อิ นพุ ต เมื่ อนาค่ า ลอจิ ก มาผ่า นวงจร
(XOR Gate)
แล้วให้ค่าลอจิกทางเอาต์พุตที่มีความสัมพันธ์
กับ อิ น พุ ต คื อ เมื่ อ อิ น พุ ต ทั้ง สองอิ น พุ ต มี ค่ า
A B Q A
ลอจิ ก เดี ย วกัน (ลอจิ ก 0 ทั้ง สองอิ นพุ ต หรื อ Q
0 0 0 B
ลอจิก 1 ทั้งสองอิ นพุต)จะทาให้เอาต์พุต มี ค่ า
0 1 1
ลอจิ ก เป็ น 0 และถ้า อิ น พุ ต มี ค่ า ลอจิ ก ต่ า งกัน
1 0 1
ส่ งผลให้ลอจิกทางเอาต์พุตเป็ นลอจิก 1
1 1 0
น็อตเกต (NOT gate)

น็อตเกตหรื อบางครั้งเรี ยกว่าอินเวอร์ เตอร์
น็อตเกต (NOT Gate)
เป็ นวงจรที่ มี อิ น พุ ต เพี ย งอิ น พุ ต เดี ย ว เมื่ อ น าค่ า
ลอจิกมาผ่านวงจรแล้วให้ค่าลอจิกทางเอาต์พุตมีค่า
A Q A Q
ลอจิกตรงข้ามกับอินพุต
0 1
1 0
แนนด์เกต (NAND gate), นอร์เกต (NOR gate)

แนนด์เกตเป็ นการรวมกันสองลอจิกเกตคือ แอนด์เกตกับน็อตเกต โดยเอาต์พุตของแอนด์เกตถูก
ส่ งให้กบั น็อตเกต ดังนั้นเอาต์พุตของแนนด์เกตจะมีสภาวะตรงกันข้ามกับแอนด์เกต
นอร์ เกตเป็ นการรวมกันสองลอจิกเกตคือ ออร์ เกตกับน็อตเกต โดยเอาต์พุตของออร์ เกตถู กส่ ง
ให้กบั น็อตเกต ดังนั้นเอาต์พุตของนอร์ เกตจะมีสภาวะตรงกันข้ามกับออร์ เกต
1.3 โครงสร้ างพืน้ ฐานของระบบคอมพิวเตอร์

ถ้าพูดถึ งระบบคอมพิวเตอร์ แล้วหลายท่านอาจมองถึ งเครื่ องคอมพิวเตอร์ ที่ใช้งานกันทัว่ ไปที่มี
จอภาพ ตัวเครื่ อง แป้ นพิมพ์ เหล่านี้ แต่ในความเป็ นจริ งระบบคอมพิวเตอร์ ไม่จาเป็ นต้องมีหน้าตาอย่างที่
รู ้จกั กันเท่านั้น เพียงแต่จะต้องประกอบด้วยส่ วนต่าง ๆ ดังนี้
1. ส่ วนรับข้อมูลหรื ออินพุต (Input)
2. ส่ วนส่ งข้อมูลหรื อเอาต์พุต (Output)
3. ส่ วนประมวลผลกลาง (Central processing unit)
4. ส่ วนเก็บข้อมูลหรื อคาสัง่ ที่เรี ยกว่าหน่วยความจา (Memory)
อินพุต หน่วยประมวลผลกลาง เอาต์พุต
หน่วยความจา
รู ปที่ 1-2 โครงสร้างพื้นฐานของระบบคอมพิวเตอร์

โดยส่ ว นต่ า ง ๆ ทั้ง หมดประกอบขึ้ น ด้ว ยอุ ป กรณ์ ว งจรอิ เ ล็ ก ทรอนิ ก ส์ ดัง นั้น ถ้า หากวงจร
อิเล็กทรอนิกส์ใด ๆ ก็ตามที่มีส่วนประกอบครบทั้ง 4 ส่ วนที่กล่าวมาข้างต้นก็จะเป็ นระบบคอมพิวเตอร์
ทันที ซึ่ งไม่จาเป็ นต้องมีลกั ษณะเหมือนกับคอมพิวเตอร์ ส่วนบุคคล (PC: Personal computer) ที่ใช้งานกัน
ทัว่ ไป
ส่ วนรับข้อมูลหรื ออินพุต
เป็ นส่ วนหรื อวงจรที่ใช้เชื่ อมต่อคอมพิวเตอร์ กบั อุ ปกรณ์ ภายนอกโดยทาหน้าที่แปลงสั ญญาณ
จากอุ ป กรณ์ ภายนอกให้มี ระดับลอจิ กที่ เหมาะสมกับวงจรภายใน เรี ย กทับ ศัพ ท์ว่า วงจรอิ นเตอร์ เฟช
(Interface circuit) เพื่อส่ งต่อให้หน่วยประมวลผลใช้เป็ นข้อมูลประกอบการประมวลผลตามชุดคาสั่งที่ได้
เขียนขึ้น เช่ นวงจรแป้ นพิมพ์เป็ นวงจรที่เปลี่ ยนพลังงานกลจากการกดแป้ นพิมพ์เป็ นพลังงานไฟฟ้ าใน
ระดับแรงดัน 5 โวลต์และ 0 โวลต์เพื่อเป็ นลอจิก 1 และลอจิก 0
ส่ วนส่ งข้อมูลหรื อเอาต์พุต
เป็ นส่ วนหรื อวงจรที่ใช้เชื่ อมต่อคอมพิวเตอร์ กบั อุปกรณ์ภายนอกโดยทาหน้าที่รับสัญญาณไฟฟ้ า
จากหน่วยประมวลผลที่เป็ นลอจิก 1 และลอจิก 0 ที่ระดับแรงดัน 5 โวลต์และ 0 โวลต์ ส่ งให้กบั อุปกรณ์
ภายนอกที่นาระดับแรงดันนี้ไปใช้งาน
ส่ วนประมวลผลกลาง
ส่ วนประมวลผลกลางเป็ นหัวใจของระบบคอมพิวเตอร์ โดยทาหน้าที่คิดประมวลผลซึ่ งมีส่วน
การประมวลผลทางคณิ ตศาสตร์ และลอจิก (Arithmetic and logic unit) หรื อที่ เรี ยกว่าทับศัพท์ว่า ALU
โดยการประมวลผลจะกระทาตามชุดคาสั่งที่เก็บไว้ในหน่วยความจา
ส่ วนเก็บข้อมูลหรื อคาสั่งที่เรี ยกว่าหน่วยความจา
เป็ นส่ วนที่ใช้เก็บข้อมูลหรื อใช้เก็บชุ ดคาสั่งที่เขียนขึ้นเพื่อให้ระบบคอมพิวเตอร์ ทางานอย่างใด
อย่างหนึ่งตามต้องการ โดยหน่วยความจาที่ใช้ในระบบคอมพิวเตอร์ มี 2 แบบด้วยกันคือ
1. หน่ วยความจาถาวร เป็ นหน่วยความจาที่มกั ใช้เก็บโปรแกรม ซึ่ งหน่วยความจาชนิดนี้จะต้องเป็ น
หน่ วยความจาที่ สามารถคงข้อมูลไว้ได้แม้กระทั้งไม่มีไฟเลี้ ยง เพื่อรั กษาคาสั่งหรื อโปรแกรมไว้เมื่อมี
ไฟเลี้ ยงจ่ายให้แก่ระบบ คอมพิวเตอร์ จะได้สามารถทางานได้ จากคุ ณสมบัติดงั กล่าว มีหน่ วยความจา
กลุ่มหนึ่ งที่รักษาข้อมูลไว้ได้แต่มีคุณสมบัติอื่นเพิ่มเติมขึ้นมาคือเป็ นหน่วยความจาที่สามารถอ่านได้เพียง
อย่างเดียวหรื อเรี ยกกันว่า ROM (Read only memory) ซึ่ งมีอยูห่ ลายชนิดได้แก่
a) ROM คุณสมบัติ โปรแกรมจากโรงงานและลบไม่ได้
b) PROM คุณสมบัติ โปรแกรมเองได้ครั้งเดียวและลบไม่ได้
c) EPROM คุณสมบัติ โปรแกรมเองได้หลายครั้งและลบได้ดว้ ยแสง UV
d) E2PROM คุณสมบัติ โปรแกรมเองได้หลายครั้งและลบได้ดว้ ยไฟฟ้า

e) Flash memory คุณสมบัติ โปรแกรมเองได้หลายครั้งและลบได้ดว้ ยไฟฟ้ า โดยสามารถ
ลบหรื อแก้ไขข้อมู ลที่ จดั เก็บไว้ใ นยูนิตของหน่ วยความจาที่ เรี ยกว่า "บล็อก" (Block) ได้ ข้อแตกต่ า ง
ระหว่าง E2PROM กับ Flash memory คือการลบหรื อแก้ไขข้อมูล ซึ่ ง E2PROM จะกระทาในระดับไบต์
2. หน่ วยความจาชั่ วคราว เป็ นหน่ วยความจาที่ใช้พกั ข้อมูลในระหว่างการประมวลผล โดยเป็ น
หน่วยความจาที่สามารถอ่านได้และเขียนข้อมูลกลับได้ในระดับไฟเลี้ยงปกติ และรักษาข้อมูลไว้ได้ตราบ
ที่ ย งั มี ไ ฟเลี้ ย งอยู่ หรื อรั ก ษาข้อมู ล ไว้ไ ด้ตราบที่ ย งั ไม่ มี ข ้อมู ล ใหม่ ม าทับ ข้อมู ล เดิ ม จากคุ ณสมบัติที่
ต้องการดังกล่าวมีหน่วยความจาที่มีให้ใช้งานเพียงแต่จะไม่สามารถรักษาข้อมูลไว้ได้ถา้ ไม่มีไฟเลี้ยง ซึ่ ง
หน่ วยความจาแบบนี้ สามารถอ่านและเขียนข้อมูลแบบสุ่ มตาแหน่ งได้ที่เรี ยกว่า RAM (Random access
memory)
1.4 ไมโครคอนโทรลเลอร์ Arduino

"Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use
hardware and software. It's intended for artists, designers, hobbyists, and anyone interested in creating
interactive objects or environments." [ www.arduino.cc] “Arduino เป็ นแพลตฟอร์ ม ต้ น แบบด้ า น
อิเล็กทรอนิ กส์ แบบโอเพ่นซอร์ ส ซึ่ งใช้ฮาร์ ดแวร์ และซอฟท์แวร์ ที่ยืดหยุ่นและใช้งานง่ าย มีไว้สาหรั บ
ศิลปิ น นักออกแบบ งานอดิเรกและทุกคนที่สนใจในการสร้างวัตถุเชิงโต้ตอบหรื อสภาพแวดล้อม”
โครงการ Arduino เดิมก่อตั้งมาด้วยผูร้ ่ วมก่อตั้ง 5 คน ได้แก่ Massimo Banzi, David Cuartielles,
David Mellis, Tom Igoe, และ Gianluca Martino โดยเริ่ มโครงการมาตั้งแต่ช่วงปี 2005 ความหมายของคา
ว่า Arduino แปลว่า เพื่อนแท้ (Strong friend หรื อ Brave friend) ในภาษาอิตาลี โดยผูก้ ่อตั้งมีความตั้งใจ
ให้ราคาของอุปกรณ์น้ นั ถูกเมื่อเทียบกับไมโครคอนโทรลเลอร์ ตระกูลอื่น ๆ เพื่อให้ทุกคนสามารถเข้าถึง
ได้โดยง่าย แพลตฟอร์ม Arduino ได้ออกแบบมาเพื่อให้ใช้งานง่าย ผูใ้ ช้งานไม่จาเป็ นต้องมีความรู ้เกี่ยวกับ
โครงสร้ า งสถาปั ตยกรรมภายในซี พียูโดยรู ้ เพี ย งว่า บอร์ ด Arduino ที่ เลื อกมาใช้งานนั้น มี ขาที่ ใ ช้งาน
อะไรบ้างมีคุณสมบัติต่าง ๆ อะไรบ้างก็สามารถใช้งานได้ ด้วยประสบการณ์และจานวณการใช้งานของ
ผูใ้ ช้จานวนมาก Arduino จึงถูกใช้งานด้านต่าง ๆ มากมาย เนื่ องจากการเขียนโค้ดโปรแกรมควบคุ มการ
ทางานของ Arduino มีความง่ายและยืดหยุน่ สามารถใช้งานในระดับสู งได้อีกด้วย เครื่ องมือที่ใช้สาหรับ
เขียนโค้ดควบคุมมีเวอร์ ชนั่ ที่สามารถรันได้ในทุกระบบปฏิ บตั ิการไม่ว่าจะเป็ น แมคอินทอช วินโดวส์
หรื อแม้กระทั้งลีนุกซ์ก็ตามทาให้ได้รับความนิยมเป็ นอย่างสู ง แพลตฟอร์ม Arduino ประกอบไปด้วย
- ฮาร์ตแวร์
- ซอฟต์แวร์
ฮาร์ ตแวร์ (Hardware)

เป็ นบอร์ ดอิเล็กทรอนิ กส์ ขนาดเล็กที่มีไมโครคอนโทรลเลอร์ เป็ นชิ้นส่ วนหลัก ประกอบร่ วมกับ
อุปกรณ์ อิเล็กทรอนิ กส์ อื่น ๆ เพื่อให้ง่ายต่อการใช้งานหรื อที่ เรี ยกกันว่า “บอร์ ด Arduino” โดยบอร์ ด
Arduino ก็มีหลายรุ่ นให้เลือกใช้ตามความเหมาะสมของงาน โดยในแต่ละรุ่ นอาจมีความแตกต่างกันใน
เรื่ องของขนาดของบอร์ ด หรื อสเปค เช่ น จานวนของขารับส่ งสัญญาณ, แรงดันไฟที่ใช้, ประสิ ทธิ ภาพ
ของ MCU เป็ นต้น
ซอฟต์ แวร์ (Software)

- ภาษาที่ใช้เขียนโค้ดควบคุมบอร์ ด Arduino เป็ นภาษาสาหรับเขียนโปรแกรมควบคุม ที่มีไวยากรณ์
แบบเดียวกับภาษา C/C++
- Arduino IDE เป็ นเครื่ องมือสาหรับเขียนโค้ดโปรแกรม การคอมไพล์โปรแกรม (การแปลงไฟล์
ภาษาซีให้เป็ นภาษาเครื่ อง) และอัปโหลดโปรแกรมลงบอร์ด
ตัวอย่างบอร์ ด Arduino ที่นิยมนามาใช้งาน
รู ปที่ 1-3 บอร์ด Arduino UNO รู ปที่ 1-4 บอร์ด Arduino Nano
รู ปที่ 1-5 บอร์ด Arduino Mega

ตารางเปรี ยบเทียบคุณสมบัติของบอร์ด Arduino รุ่ นต่าง ๆ (เฉพาะบางรุ่ น)
Operating CPU Analog Digital EEPROM SRAM Flash
Name Processor In/Out IO/PWM [kB] [kB] [kB] USB UART
Input Voltage Speed
101 Intel® Curie 3.3 V / 7-12V 32MHz 6 /0 14 / 4 - 24 196 Regular -
Gemma ATtiny85 3.3 V / 4-16 V 8 MHz 1 /0 3 /2 0.5 0.5 8 Micro 0
ATmega168V 2.7-5.5 V
LilyPad 8MHz 6 /0 14 / 6 0.512 1 16 - -
ATmega328P 2.7-5.5 V
LilyPad 2.7-5.5 V 4 /0 9 /4 - -
ATmega328P 8 MHz 1 2 32
SimpleSnap
LilyPad USB ATmega32U4 3.3 V / 3.8-5 V 8 MHz 4 /0 9 /4 1 2.5 32 Micro -
Mega 2560 ATmega2560 5 V / 7-12 V 16 MHz 16 / 0 54 / 15 4 8 256 Regular 4
Micro ATmega32U4 5 V / 7-12 V 16 MHz 12 / 0 20 / 7 1 2.5 32 Micro 1
ATmega168 3.3 V / 3.35-12 V 8 MHz 0.512 1 16
Pro 6 /0 14 / 6 - 1
ATmega328P 5 V / 5-12 V 16 MHz 1 2 32
3.3 V / 3.35-12 V 8 MHz
Pro Mini ATmega328P 6 /0 14 / 6 1 2 32 - 1
5 V / 5-12 V 16 MHz
Uno ATmega328P 5 V / 7-12 V 16 MHz 6 /0 14 / 6 1 2 32 Regular 1
Zero ATSAMD21G18 3.3 V / 7-12 V 48 MHz 6 /1 14 / 10 - 32 256 2 Micro 2
Due ATSAM3X8E 3.3 V / 7-12 V 84 MHz 12 / 2 54 / 12 - 96 512 2 Micro 4
Esplora ATmega32U4 5 V / 7-12 V 16 MHz - - 1 2.5 32 Micro -
Ethernet ATmega328P 5 V / 7-12 V 16 MHz 6 /0 14 / 4 1 2 32 Regular -
Leonardo ATmega32U4 5 V / 7-12 V 16 MHz 12 / 0 20 / 7 1 2.5 32 Micro 1
Mega ADK ATmega2560 5 V / 7-12 V 16 MHz 16 / 0 54 / 15 4 8 256 Regular 4
Mini ATmega328P 5 V / 7-9 V 16 MHz 8 /0 14 / 6 1 2 32 - -
ATmega168 0.512 1 16
Nano 5 V / 7-9 V 16 MHz 8 /0 14 / 6 Mini 1
ATmega328P 1 2 32
ATmega32U4 16 MHz 2.5 32
Yùn 5V 12 / 0 20 / 7 1 Micro 1
AR9331 Linux 400MHz 16MB 64MB
บทที่ 2 การเขียนโปรแกรมภาษาซีสาหรับไมโครคอนโทรลเลอร์  17
บทที่ 2
การเขียนโปรแกรมภาษาซีสาหรับไมโครคอนโทรลเลอร์
2.1 ขั้นตอนในการพัฒนาโปรแกรม
2.2 ภาษาซีสาหรับไมโครคอนโทรลเลอร์
2.3 การสร้างฟังก์ชนั่ รองขึ้นใช้เอง
การเขียนโปรแกรมควบคุมการทางานไมโครคอนโทรลเลอร์ ดว้ ยภาษาซี เป็ นการเขียนโปรแกรม
ที่มีความยืดหยุน่ มากกว่าและสามารถพัฒนางานได้เร็ วกว่าการเขียนโปรแกรมด้วยภาษาแอสเซมบลี การ
เขียนโปรแกรมเพื่อควบคุมการทางานของ Arduino ยึดหลักวิธีการเขียนตามไวยากรณ์ภาษาซี ดังนั้นเมื่อ
สามารถเขียนโปรแกรมควบคุมการทางานไมโครคอนโทรลเลอร์ Arduino นี้ ได้ก็สามารถนาความรู ้ไป
เขียนโปรแกรมภาษาซี ไมโครคอนโทรลเลอร์ อื่น ๆ ได้
แสดงความรู ้ เกี่ ยวกับการเขียนผังงาน (Flow chart) การตรวจสอบความถู กต้องของการเขี ย น
โปรแกรมจากผังงาน และสามารถเขียนโปรแกรมจากผังงาน
1. เพื่อให้มีความรู ้เกี่ยวกับขั้นตอนในการพัฒนาโปรแกรม
2. เพื่อให้มีความรู ้เกี่ยวกับภาษาซีสาหรับไมโครคอนโทรลเลอร์
3. เพื่อให้มีความรู ้เกี่ยวกับการสร้างฟังก์ชนั่ รองขึ้นใช้เอง
1. บอกเกี่ยวกับขั้นตอนในการพัฒนาโปรแกรมได้
2. บอกเกี่ยวกับภาษาซีสาหรับไมโครคอนโทรลเลอร์ ได้
3. บอกวิธีการสร้างฟังก์ชนั่ รองขึ้นใช้เองได้
การเขียนโปรแกรมภาษาซีสาหรับไมโครคอนโทรลเลอร์
การใช้งานไมโครคอนโทรลเลอร์ นอกจากจะต้องมีวงจรไมโครคอนโทรลเลอร์ และมีส่วนของ
วงจรเชื่ อมต่ อกับ อุ ป กรณ์ ภายนอกเพื่ อใช้ใ นการควบคุ ม งานต่ า ง ๆ ตามต้องการที่ เรี ย กว่า ฮาร์ ด แวร์
(Hardware) แล้วจาเป็ นต้องมีชุดคาสั่งหรื อโปรแกรมไว้สาหรับสั่งงานให้ไมโครคอนโทรลเลอร์ ทางาน
ตามที่ตอ้ งการซึ่ งเรี ยกว่าซอฟท์แวร์ (Software) ในบทนี้ เป็ นการเรี ยนรู ้หลักการเขียนโปรแกรมควบคุม
การทางานของไมโครคอนโทรลเลอร์
2.1 ขั้นตอนในการพัฒนาโปรแกรม
โปรแกรมคอมพิ ว เตอร์ ที่ น ามาใช้ ง านได้ น้ ั น ไม่ ส ามารถเริ่ มต้น จากการเขี ย นค าสั่ ง ด้ว ย
ภาษาคอมพิวเตอร์ ได้ทนั ที จะต้องมีการวิเคราะห์ วางแผน และปฏิบตั ิตามกระบวนการทางาน ซึ่ งแบ่ง
ออกเป็ น 5 ขั้นตอน คือ
1. วิเคราะห์ ปัญหา โดยจะเริ่ มจากการวิเคราะห์ผลลัพธ์ที่ตอ้ งการ (Output) แล้วย้อนกลับไปยัง
ข้อมูลที่นาเข้าสู่ ระบบ (Input) ตลอดจนข้อมูลอื่น ๆ ที่เกี่ ยวข้องในการที่จะนาไปใช้ในการ
ประมวลผล
2. ออกแบบวิธีการแก้ ปัญหา เมื่อทราบผลลัพธ์ที่ตอ้ งการและข้อมูลที่นาเข้าสู่ ระบบแล้ว ต้อง
กาหนดการวางแผนในการแก้ปัญหา โดยใช้วิธีเขียนลาดับขั้นตอนการแก้ปัญหาที่เรี ยกว่า
อัลกอริ ทึม (Algorithm ) และใช้เครื่ องมือสาหรับช่วยในการเขียนอัลกอริ ทึมเช่ น การเขียน
รหัสจาลอง (Pseudo code) การเขียนผังงาน (Flowchart) เป็ นต้น
3. เขียนโปรแกรม เลื อกภาษาคอมพิวเตอร์ ที่เหมาะสม โดยพิจารณาจากความสามารถของ
ผูเ้ ขียนโปรแกรมและประสิ ทธิ ภาพของภาษาคอมพิวเตอร์ น้ นั ๆ ให้เหมาะสมกับระบบงานที่
ต้องการแล้วเขียนชุดคาสั่งเป็ นภาษาคอมพิวเตอร์ ตามอัลกอริ ทึมที่ได้ออกแบบไว้
4. ทดสอบและแก้ ไขโปแกรม ภายหลังจากเขี ยนโปรแกรมเสร็ จสิ้ น จะต้องทาการทดสอบ
โปรแกรมเพื่อหาข้อผิดพลาด (Error) ซึ่ งข้อผิดพลาดที่พบในขั้นตอนการทดสอบโปรแกรม
นั้นจะต้องนามาปรับปรุ งแก้ไขโปรแกรมเพื่อให้สามารถทางานได้ตามต้องการ
5. จัดทาเอกสารประกอบ เมื่อโปรแกรมผ่านการทดสอบแล้วก็จะต้องจัดทาเอกสารประกอบ
ซึ่ งมีรายละเอียดของวิธีการใช้งานโปรแกรม วิธีการติดตั้งโปรแกรม ตลอดจนขั้นตอนใน
การพัฒนาโปรแกรม รวมถึงอัลกอริ ทึมและโปรแกรมต้นฉบับ (Source code) เพื่อประโยชน์
ในกรณี ที่ตอ้ งการแก้ไขหรื อปรับปรุ งโปรแกรมภายหลัง1
ดร. ศรี ไพร ศักดิ์รุ่งไพรศาลกุล “หลักการเขียนโปรแกรม” http://www.gotoknow.org/blogs/posts/269964

1
ขั้นตอนวิธี หรื อ Algorithm (ภาษาไทย : อัลกอริ ทึม) หมายถึงกระบวนการแก้ปัญหาที่สามารถ

เข้าใจได้ มีลาดับหรื อวิธีการในการแก้ไขปั ญหาใดปั ญหาหนึ่ งอย่างเป็ นขั้นเป็ นตอนและชัดเจน เมื่อนาเข้า
อะไรแล้ว จะต้อ งได้ผ ลลัพ ธ์ เ ช่ น ไร ซึ่ งแตกต่ า งจากการแก้ปั ญ หาแบบสามัญ ส านึ ก หรื อ ฮิ ว ริ ส ติ ก
(Heuristic) โดยทัว่ ไปขั้นตอนวิธี จะประกอบด้วย วิธีการเป็ นขั้น ๆ และมีส่วนที่ตอ้ งทาแบบวนซ้ า หรื อ
เวียนเกิดโดยใช้ตรรกะ และ/หรื อ ในการเปรี ยบเทียบในขั้นตอนต่าง ๆ จนกระทัง่ เสร็ จสิ้ นการทางาน
ในการทางานอย่างเดียวกันเราอาจจะเลือกขั้นตอนวิธีที่ต่างกันเพื่อแก้ปัญหาได้โดยที่ผลลัพธ์ที่ได้
ในขั้นสุ ดท้ายจะออกมาเหมือนกันหรื อไม่ก็ได้ และจะมีความแตกต่างที่จานวนและชุ ดคาสั่งที่ใช้ต่างกัน
ซึ่ งส่ งผลให้เวลาและขนาดหน่วยความจาที่ตอ้ งการต่างกัน หรื อเรี ยกได้อีกอย่างว่ามีความซับซ้อนต่างกัน
การนาขั้นตอนวิธีไปใช้ไม่จากัดเฉพาะการเขียนโปรแกรมคอมพิวเตอร์ แต่สามารถนาไปใช้กบั
ปั ญ หาอื่ น ๆ ได้เ ช่ น การออกแบบวงจรไฟฟ้ า , การท างานเครื่ อ งจัก รกล, หรื อ แม้ก ระทั่ง ปั ญ หาใน
ธรรมชาติ เช่น วิธีของสมองมนุษย์ในการคิดเลข หรื อวิธีการขนอาหารของแมลง2
ผัง งาน (Flowchart) คื อ รู ป ภาพ (Image) หรื อ สั ญ ลัก ษณ์ ( Symbol) ที่ ใ ช้เ ขี ย นแทนขั้น ตอน
คาอธิ บาย ข้อความ หรื อคาพูดที่ใช้ในอัลกอริ ทึม (Algorithm) เพราะการนาเสนอขั้นตอนของงานให้
เข้าใจตรงกัน ระหว่างผูเ้ กี่ยวข้อง ด้วยคาพูด หรื อข้อความทาได้ยากกว่า3
ผังงานในการเขียนโปรแกรมเป็ นรู ปทรงเลขาคณิ ต ที่บรรจุรายละเอียดกระบวนการประมวลผล
โดยมีรูปทรงในการใช้งานหลัก ๆ (เฉพาะงานไมโครคอนโทรลเลอร์ ) ดังนี้
ตารางที่ 2-1 ผังงานหลักที่ใช้งานไมโครคอนโทรลเลอร์

รู ปทรง ชนิดการประมวลผล ตัวอย่างเส้นทาง
จุ ด เริ่ ม ต้น หรื อ จุ ด สิ้ น สุ ด
ของโปรแกรม
กระบวนการประมวลผล
การตัดสิ นใจ
ชุ ด กระบวนการที่ เตรี ย ม
ไว้แล้ว (โปรแกรมย่อย)
http://www.com5dow.com
2
http://158.108.203.7/student/simple/?t46.html
3
ตารางที่ 2-1 ผังงานหลักที่ใช้งานไมโครคอนโทรลเลอร์ (ต่อ)

รู ปทรง ชนิดการประมวลผล ตัวอย่างเส้นทาง
จุดเชื่ อมในหน้าเดียวกัน
จุดเชื่อมในหน้าอื่น
ตัวอย่างการเขียนลาดับขั้นขั้นตอนวิธี และการแปลงเป็ นผังงาน

ยกตัวอย่างในชีวติ ประจาวันเพื่อให้ง่ายต่อการจินตนาการ โจทย์การทาไข่เจียวหมูสับ
ขั้นที่ 1 เขียนลาดับขั้น (Algorithm)
1. เตรี ยมวัสดุ ไข่,หมูสับ,กระทะ,เตาไฟ,น้ ามันพืช ,ถ้วย,จาน 6. ถ้ากระทะร้อนใส่ ไข่ลงไป
2. เอากระทะตั้งไฟ (อุ่นกระทะ) 7. รอให้หนึ่งด้านสุ ก
3. ใส่ น้ ามันพืช 8. กลับด้าน
4. ตอกไข่ใส่ ถว้ ยใส่ หมูสับ 9. รอให้ดา้ นที่ 2 สุ ก
5. ตีจนเข้ากัน 10. ตักออกใส่ จาน (เสร็ จ)
ขั้นที่ 2 แปลงลาดับขั้นเป็ นผังงาน (Flowchart)
เริ่ ม
เตรี ยมวัสดุ ไข่,หมูสับ,กระทะ... B
เอากระทะตั้งไฟ ใส่ ไข่ลงกระทะ
ใส่ น้ ามันพืช
ด้าน 1 สุ กหรื อไม่
ไม่ใช่
ตอกไข่ใส่ ถว้ ยใส่ หมูสับ ใช่
กลับด้าน
ตีไข่
ด้าน 2 สุ กหรื อไม่
ไม่ใช่ ไม่ใช่
เข้ากันหรื อไม่ ใช่
ใช่ ตักใส่ จาน
กระทะร้อนหรื อไม่
ไม่ใช่ เสร็ จ
ใช่
B
ตัวอย่างการเขียนโปรแกรมไมโครคอนโทรลเลอร์
ตัวอย่างจงเขียนโปรแกรมไฟกระพริ บ LED ที่ต่ออยูท่ ี่ขา D13
ขั้นที่ 1 เขียนลาดับขั้น (Algorithm) ขั้นที่ 2 แปลงลาดับขั้นเป็ นผังงาน (Flowchart)
1. กาหนดชื่อ LED กับขาที่เชื่อมต่อ START
2. กาหนดโหมดของขาใช้งาน
กาหนดช่อ LED
3. เขียนลอจิก 1 ไปที่ขาเชื่อม LED
4. หน่วงเวลา เขียนลอจิก 1 ไปที่ขา
5. เขียนลอจิก 2 ไปที่ขาเชื่อม LED
หนวงเวลา
6. หน่วงเวลา
7. กระโดดกลับไปทาในขั้นตอนที่ 3 เขียนลอจิก 0 ไปที่ขา
หนวงเวลา
ขั้นที่ 3 แปลงผังงานเป็ นโปรแกรม

#define LED 13
void setup()
{
pinMode(LED, OUTPUT);
}
void loop()
{
digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
2.2 ภาษาซีสาหรับไมโครคอนโทรลเลอร์
ไมโครคอนโทรลเลอร์ ไม่วา่ จะเป็ นตระกูลใดก็ตามจะทางานได้ก็ต่อเมื่อมีชุดคาสั่งที่สั่งให้ทางาน
ตามที่ตอ้ งการที่เรี ยกว่าโปรแกรม โดยคาสั่งหรื อโปรแกรมที่ไมโครคอนโทรลเลอร์ เข้าใจและสามารถ
ทางานได้อยูใ่ นรู ปของรหัสลอจิก 0 และ 1 หากนาลอจิกมาจับกลุ่มก็เป็ นเลขฐาน 16 ที่เรี ยกว่าภาษาเครื่ อง
ซึ่ งภาษาเครื่ องเป็ นภาษาที่มนุษย์ไม่สามารถเข้าใจได้เนื่ องจากเป็ นเลขฐาน 16 ทั้งหมด ดังนั้นในการเขียน
โปรแกรมจึงจาเป็ นต้องใช้ภาษาที่มนุ ษย์สามารถเข้าใจได้ โดยภาษาที่มนุ ษย์เข้าใจได้และใกล้ เคี ยงกับ
ภาษาเครื่ องมากที่สุดคือภาษาแอสเซมบลี แต่เนื่ องจากการพัฒนางานโดยใช้ภาษาแอสเซมบลีเป็ นไปได้
ยากและซับซ้อน เพื่อให้ง่ายและรวดเร็ วต่อการพัฒนาโปรแกรมใช้งานไมโครคอนโทรลเลอร์ ภาษาที่
เหมาะสมคือภาษาซี
โครงสร้างของภาษาซี
ภาษาซี เป็ นภาษาที่ได้รับความนิ ยมสู งเป็ นภาษาโครงสร้างง่ายต่อการทาความเข้าใจง่ายต่อการ
นาไปพัฒนาต่อ สามารถเขียนโปรแกรมแยกเป็ นส่ วน ๆ โดยแต่ละส่ วนสามารถเรี ยกใช้งานได้จากส่ วน
อื่นของโปรแกรมทาให้สามารถแบ่งงานให้หลายคนไปพัฒนาได้ การเขียนโปรแกรมเป็ นส่ วน ๆ เรี ยกว่า
ฟั ง ก์ชั่น โครงสร้ า งของภาษาซี มี ส่ วนประกอบ 2 ส่ วนคื อ ส่ วนหัวโปรแกรมและส่ วนตัวโปรแกรม
ส่ วนตัวโปรแกรมจะมีฟังก์ชนั่ หลักชื่อว่า main( ) เพื่อเป็ นส่ วนหลักในการทางาน และอาจมีฟังก์ชนั่ อื่นที่
ผูใ้ ช้เขียนขึ้นเพื่อใช้งานเรี ยกว่าฟังก์ชนั่ รอง
หัวโปรแกรม
ตัวโปรแกรม
ฟังก์ชนั่ หลัก main( )
ฟังก์ชนั่ รองที่เขียนเพิม่ ขึ้น
รู ปที่ 2-1 โครงสร้างภาษาซี
โครงสร้างของภาษาซีสาหรับ Arduino
โครงสร้างภาษาซีสาหรับ Arduino ถูกจัดใหม่ให้ง่ายต่อผูใ้ ช้งานเบื้องต้นซึ่ งผูอ้ อกแบบได้จดั วาง
ให้ผใู ้ ช้งานได้ใช้งานง่ายซึ่ งโครงสร้างหลัก ๆ จะมีเพียง 2 ส่ วนเท่านั้นคือ
1. setup เป็ นส่ วนที่เก็บฟังก์ชนั่ ที่ทางานครั้งเดียว
2. loop เป็ นส่ วนที่เก็บฟังก์ชนั่ ที่เมื่อทางานครบแล้วจะวนกลับมาทาซ้ าใหม่ต้ งั แต่ตน้
แต่ถา้ ต้องการเขียนโปรแกรมขั้นสู งสามารถเขียนในส่ วนหัวโปรแกรมและส่ วนของฟังก์ชนั่ รอง
ที่เขียนขึ้นใช้งานเองเพื่อให้ใช้งานสะดวกมากยิง่ ขึ้นได้เช่นเดียวกับภาษาซี มาตรฐาน
ตัวโปรแกรม
ตัวโปรแกรม ฟังก์ชนั่ ที่ทางานครั้งเดียว setup( )
ฟังก์ชนั่ ที่ทางานครั้งเดียว setup( )
ฟังก์ชนั่ ที่เวียนกลับทางานวนซ้ า loop( )
ฟังก์ชนั่ ที่เวียนกลับทางานวนซ้ า loop( ) ฟังก์ชนั่ รองที่เขียนขึ้นเอง
(พื้นฐาน) (ขั้นสู ง)
รู ปที่ 2-2 โครงสร้างภาษาซี สาหรับ Arduino
ตัวอยางโปรแกรมทีเ่ ขียนด้ วยโครงสร้ างแบบพน้ ฐาน

void setup()
{
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT); ฟังก์ชนั่ ที่ทางานครั้งเดียว setup( )
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
}
void loop()
{
digitalWrite(2,HIGH);
digitalWrite(3,LOW);
delay(200);
delay(200); ฟังก์ชนั่ ที่เวียนกลับทางานวนซ้ า loop( )
delay(200);
delay(200);
}
ตัวอยางโปรแกรมทีเ่ ขียนด้ วยโครงสร้ างแบบขั้นสู ง (ทีใ่ ห้ ผลแบบเดียวกับขั้นพน้ ฐาน)

#define LED1 2
#define LED2 3
#define LED3 4
#define LED4 5 หัวโปรแกรม
char LED_pin[] = {LED1,LED2,LED3,LED4};
void send2port(byte data);
void setup()
{
Serial.begin(9600);
for(char i=0;i<4;i++)
{ ฟังก์ชนั่ ที่ทางานครั้งเดียว setup( )
pinMode(LED_pin[i],OUTPUT);
}
}
void loop()
{
send2port(0B1000);delay(200);
send2port(0B0100);delay(200); ฟังก์ชนั่ ที่เวียนกลับทางานวนซ้ า loop( )
}
void send2port(byte data)
{
ฟังก์ชนั่ รองที่เขียนขึ้นเอง
if (data & 1 ){digitalWrite(LED_pin[0],HIGH);} else {digitalWrite(LED_pin[0],LOW);}
}
ตัวแปรในภาษาซี
การประกาศตัวแปรคือการจองพื้นที่ในหน่วยความจาเพื่อนาไปใช้งานในฟั งก์ชนั่ โดยการใช้ชื่อ
ตัวแปรแทนการกาหนดเป็ นค่าแอดเดรสของหน่วยความจา รู ปแบบของการประกาศตัวแปรเป็ นดังนี้
ชนิดของตัวแปร ชื่อตัวแปร;
หรื อ ชนิดของตัวแปร ชื่อตัวแปรที่1,ชื่อตัวแปรที่ 2,… ;
หลักการตั้งชื่อตัวแปรในภาษาซี
หลักการตั้งชื่อตัวแปรมีขอ้ กาหนดหลัก ๆ อยู่ 4 ประการด้วยกันคือ
1. ชื่อที่ต้ งั ต้องไม่ซ้ ากับคาสงวนของภาษาซี (คาที่ภาษาซี มีใช้งานอยูแ่ ล้ว)
2. การใช้ตวั อักษรใหญ่กบั ตัวอักษรเล็กถือว่าเป็ นคนละตัว
3. ตัวแรกของชื่อตัวแปรต้องเป็ นตัวอักษรเท่านั้นตัวถัดไปเป็ นตัวเลขได้
4. ชื่อตัวแปรห้ามเว้นวรรค
ชนิดของตัวแปรในภาษาซีสาหรับไมโครคอนโทรลเลอร์ Arduino
ตารางที่ 2-2 ชนิดของตัวแปรในภาษาซีสาหรับไมโครคอนโทรลเลอร์ Arduino
ขนาด
ชนิด ขอบเขต
บิต ไบต์
boolean 8 1 true, false
char 8 1 -128 ถึง +127
unsigned char 8 1 0 ถึง 255
byte 8 1 0 ถึง 255
int 16 2 -32768 ถึง +32767
unsigned int 16 2 0 ถึง 65535
long 32 4 -2147483648 ถึง +2147483647
unsigned long 32 4 0 ถึง 4294967295
float 32 4 ±3.4E±38 (~7 digits)
double 64 8 ±1.7E±308 (~15 digits)
พอยน์เตอร์
พอยน์เตอร์ เป็ นตัวชี้ ตาแหน่งข้อมูลของตัวแปรอื่นที่เก็บในหน่วยความจา โดยตัวพอยน์เตอร์ เป็ น
ตัว เก็ บ ต าแหน่ ง แทนการเก็ บ ข้อ มู ล ในการใช้ง านพอยน์ เ ตอร์ จ ะใช้เ ครื่ อ งหมาย * น าหน้า และใช้
เครื่ องหมาย & เมื่อต้องการค่าตาแหน่งของตัวแปรอื่นโดยมีรูปแบบดังนี้
รู ปแบบ
ชนิดของตัวแปร * ชื่อตัวแปร;
ตัวอยาง
int *n;
int i;
i=10;
n=&i;
อาร์เรย์
อาร์ เรย์เป็ นการเพิ่มความสามารถในการเก็บข้อมูลของตัวแปรให้สามารถเก็บเป็ นชุ ดได้ โดยใช้
ชื่ อตัวแปรเดิมได้ การใช้งานตัวแปรอาร์ เรย์จะใช้เครื่ องหมาย [ ] ต่อท้ายตัวแปรโดยภายในวงเล็บ เป็ น
ตัวเลข ซึ่ งสามารถใช้งานได้หลายมิติ มีรูปแบบดังนี้
รู ปแบบ
ชนิดของตัวแปร ชื่อตัวแปร[ตัวเลข]; // เป็ นอาร์เรย์ 1 มิติ
ชนิดของตัวแปร ชื่อตัวแปร[ตัวเลข,ตัวเลข]; // เป็ นอาร์เรย์ 2 มิติ
ชนิดของตัวแปร ชื่อตัวแปร[ตัวเลข,ตัวเลข,ตัวเลข]; // เป็ นอาร์เรย์ 3 มิติ
ตัวอยางอาร์ เรย์ 1 มิติ

int x[4]; x[0] x[1] x[2] x[3]
ตัวอยางอาร์ เรย์ 2 มิติ x[0,0] x[0,1] x[0,2]
int x[3,3]; x[1,0] x[1,1] x[1,2]
x[2,0] x[2,1] x[2,2]
ตัวอยางอาร์ เรย์ 3 มิติ x[0,0,1] x[0,1,1] x[0,2,1]

x[0,0,0] x[0,1,0] x[0,2,0]
int x[3,3,2]; x[1,0,0] x[1,1,0] x[1,2,1]
x[1,0,0] x[1,1,0] x[1,2,0]
x[2,0,0] x[2,1,0] x[2,2,1]
x[2,0,0] x[2,1,0] x[2,2,0]
ตัวดาเนินการในภาษาซี
ตัวดาเนินการในภาษาซี แบ่งตามลักษณะการกระทาได้ 5 กลุ่มด้วยกันคือ
1. ตัวกระทาทางคณิ ตศาสตร์
2. ตัวกระทาทางลอจิกระดับบิต
3. ตัวกระทาบูลีน
4. ตัวกระทาเปรี ยบเทียบ
5. ตัวกระทาประสม
โดยในแต่ละลักษณะมีรายละเอียดดังต่อไปนี้
ตารางที่ 2-3 ตัวกระทาทางคณิ ตศาสตร์

เครื่ องหมาย การกระทา ตัวอย่าง คาอธิบาย
+ บวก x=y+z; x เท่ากับค่าในตัวแปร y บวกกับค่าในตัวแปร z
- ลบ x=y-z; x เท่ากับค่าในตัวแปร y ลบด้วยค่าในตัวแปร z
* คูณ x=y*z; x เท่ากับค่าในตัวแปร y คูณด้วยค่าในตัวแปร z
/ หาร x=y/z; x เท่ากับค่าในตัวแปร y หารด้วยค่าในตัวแปร z
% หารเอาเศษ x=y%z; x เท่ากับเศษของการหารระหว่างตัวแปร y กับตัวแปร z
ตารางที่ 2-4 ตัวกระทาทางลอจิก

& แอนด์ x=y&z; x เท่ากับค่าในตัวแปร y แอนด์กบั ค่าในตัวแปร z
| ออร์ x=y|z; x เท่ากับค่าในตัวแปร y ออร์ กบั ค่าในตัวแปร z
^ เอ็กซ์คลูซิฟออร์ x=y^z; x เท่ากับค่าในตัวแปร y เอ็กซ์คลูซิฟออร์ กบั z
~ วันคอมพลีเมนต์ x=~y; x เท่ากับค่าตรงข้ามของค่าในตัวแปร y
<< เลื่อนไปทางซ้าย x=x<<1; เลื่อนข้อมูลใน x ไปทางซ้ายไป 1 บิต
>> เลื่อนไปทางขวา x=x>>2; เลื่อนข้อมูลใน x ไปทางขวาไป 2 บิต
ตารางที่ 2-5 ตัวกระทาบูลีน

เครื่ องหมาย การกระทา คาอธิบาย
&& แอนด์ เชื่อมเงื่อนไข 2 เงื่อนไขด้วยคาว่า “และ”
|| ออร์ เชื่อมเงื่อนไข 2 เงื่อนไขด้วยคาว่า “หรื อ”
! อินเวิร์ส ใช้ตรวจสอบตัวแปรว่าเท่ากับศูนย์หรื อไม่เช่น if (!x)
ตารางที่ 2-6 ตัวกระทาการเปรี ยบเทียบ

> มากกว่า x>10 x มากกว่า 10
< น้อยกว่า x<10 x น้อยกว่า 10
>= มากกว่าหรื อเท่ากับ x>=10 x มากกว่าหรื อเท่ากับ 10
<= น้อยกว่าหรื อเท่ากับ x<=10 x น้อยกว่าหรื อเท่ากับ 10
== เท่ากับ x= =10 x เท่ากับ 10
!= ไม่เท่ากับ x!=10 x ไม่เท่ากับ 10
ตารางที่ 2-7 ตัวกระทาประสม

++ เพิ่มค่า 1 ค่า x++; เพิ่มค่า x ขึ้น 1 ค่า
-- ลดค่า 1 ค่า x--; ลดค่า x ลง 1 ค่า
+= บวก x+=2; x ใหม่เท่ากับ x เดิมบวกกับ 2
-= ลบ x-=2; x ใหม่เท่ากับ x เดิมลบด้วย 2
*= คูณ x*=2; x ใหม่เท่ากับ x เดิมคูณด้วย 2
/= หาร x/=2; x ใหม่เท่ากับ x เดิมหารด้วย 2
%= หารเอาเศษ x%=2; x ใหม่เท่ากับ x เดิมหารด้วย 2 แล้วเอาเศษ
&= แอนด์ x&=2; x ใหม่เท่ากับ x เดิมแอนด์ดว้ ย 2
|= ออร์ x|=2; x ใหม่เท่ากับ x เดิมออร์ดว้ ย 2
ไวยากรณ์ ภาษาซี
1. ประกาศช่ อแทน เป็ นการประกาศใช้ชื่ออื่ นแทนค่าที่ ต้องการเพื่ อให้สะดวกต่อการเขี ย น
โปรแกรม รู ปแบบเป็ นดังนี้
#define constantName value
constantName: ชื่อที่ตอ้ งการกาหนดตั้ง
value: ค่าที่ตอ้ งการกาหนดให้ชื่อนั้นมีค่าเท่ากับ
#define LED 13
หมายถึง กาหนดให้คาว่า LED มีค่าเท่ากับ 13
2. การรวมไฟล์ อ่นเข้ ามารวม เป็ นการประกาศไฟล์อื่น ๆ เข้ามารวมกับตัวโปรแกรมก่อนการ

คอมไพล์ รู ปแบบเป็ นดังนี้
#include <file>
#include "file"
file: ชื่อไฟล์ที่ตอ้ งการนาเข้ามารวมกับโค้ดโปรแกรมที่กาลังเขียนขึ้น
#include <SPI.h>
หมายถึง ให้โปรแกรมคอมไพลเลอร์ทาการรวมไฟล์ที่ชื่อ SPI.h ก่อนทาการคอมไพล์
3. การใสหมายเหตุลงในโค้ ดโปรแกรม เป็ นการใส่ ขอ้ ความใด ๆ ลงในโค้ดโปรแกรมเพื่อที่จะ

อธิ บายโปรแกรมหรื อเพื่อบันทึกความจาว่าโค้ดในตาแหน่งนั้น ๆ เขียนขึ้นเพื่อประสงค์สิ่ง
ใด การใส่ หมายเหตุจะต้องใส่ เครื่ องหมายเพื่อให้คอมไพล์เลอร์ ขา้ มการคอมไพล์ในส่ วนนี้
รู ปแบบเป็ นดังนี้
//................ ใช้ ในกรณีบรรทัดเดียว
/*..............*/ ใช้ ในกรณีหลายบรรทัด
4. การใสเคร่ องหมายท้ ายฟั งก์ ชั่น ภาษาซี เป็ นภาษาที่มีการใส่ เครื่ องหมายท้ายฟั งก์ชนั่ ซึ่ ง
เป็ นสิ่ งที่แตกต่างและโดดเด่นกว่าโปรแกรมในภาษาอื่น ๆ โดยมีหลักคิดดังนี้
; สาหรับฟังก์ชั่นทีท่ างานเสร็จสิ้นในตัว
{} สาหรับฟังก์ชั่นทีม่ ฟี ังก์ชั่นอ่นรวมเข้ าไปด้ วย
ฟังก์ชั่นการดาเนินการแบบทางเลอก
ในการเขียนโปรแกรมเพื่อให้ไมโครคอนโทรลเลอร์ ทางานในสิ่ งที่ตอ้ งการ นอกจากฟังก์ชนั่ ที่สงั่
ให้ทางานเป็ นลาดับแล้ว จาเป็ นต้องใช้ฟังก์ชนั่ ที่มีการทางานแบบให้เลือกเส้นทางการทางาน โดยการทา
ตามเงื่อนไข หรื อการให้ทาซ้ าแบบมีเงื่ อนไขหรื อไม่มีเงื่ อนไข โดยฟั งก์ชนั่ ที่มีการทางานแบบทางเลือก
ในภาษาซี มีดว้ ยกัน 4 ฟังก์ชนั่ คือ
1. ฟังก์ชนั่ if
2. ฟังก์ชนั่ if-else
3. ฟังก์ชนั่ if-else if-else
4. ฟังก์ชนั่ switch
ฟังก์ชนั่ if (ทางเลือกเดียว)
ฟังก์ชนั่ if เป็ นฟังก์ชนั่ ที่มีการตรวจสอบเงื่อนไข โดยถ้าเงื่อนไขเป็ นจริ งจะทางานตามชุดฟังก์ชนั่
ที่กาหนดไว้ รู ปแบบเป็ นดังนี้
if (เง่อนไขทีต่ รวจสอบ)
ผังงาน โค้ ดโปรแกรม
if (conditional)
{
// put your code here
ไม่ใช่
เง่ อนไข }
// if conditional true
ใช่ Example:
ชุ ดฟังก์ชั่นเม่อเง่ อนไข if (value<50)
{
เป็ นจริ ง digitalWrite(13,HIGH);
}
*หากชุดฟังก์ชนั่ ที่ให้ทางานเมื่อเงื่อนไขเป็ นจริ งมีเพียงฟังก์ชนั่ เดียว ไม่ตอ้ งใส่ วงเล็บปี กกา {…} ก็ได้
ฟังก์ชนั่ if-else (สองทางเลือก)
การตรวจสอบเงื่อนไขที่มีชุดฟั งก์ชนั่ ให้ทางานเมื่อเงื่ อนไขเป็ นจริ งและมีชุดฟั งก์ชนั่ ให้ทางาน
เมื่อเงื่อนไขเป็ นเท็จ เราจะใช้ฟังก์ชนั่ if-else มาใช้งาน มีรูปแบบดังนี้
if (เง่อนไขทีต่ รวจสอบ) else
if (conditional)
{
// put main code here
ใช่ ไม่ใช่
เง่ อนไข }
// if conditional true
else
{
ชุ ดฟังก์ชั่นเม่อ ชุ ดฟังก์ชั่นเม่อ //put main code here
//if conditional false
เง่ อนไขเป็ นจริง เง่ อนไขเป็ นเท็จ }
ฟังก์ชนั่ if-else if....else (หลายทางเลือก)

เป็ นฟังก์ชนั่ ที่มีการตรวจสอบเงื่อนไขหลายเงื่อนไข และมีชุดฟังก์ชนั่ ที่เตรี ยมให้ทางานในแต่ละ
เงื่อนไขหากเงื่อนไขนั้น ๆ ถูกต้อง
if (เง่อนไขทีต่ รวจสอบ) else if (เง่อนไขทีต่ รวจสอบ)
if (conditional1)
{
// put main code here
ใช่ ชุ ดฟังก์ชั่นเม่อ
เง่ อนไขที่ 1 // if conditional1 true
เง่ อนไข 1 เป็ นจริ ง }
ไม่ใช่ else if (conditional2)
ใช่ ชุ ดฟังก์ชั่นเม่อ {
เง่ อนไขที่ 2
เง่ อนไข 2 เป็ นจริ ง //put main code here
//if conditional2 true
ไม่ใช่ }
ฟังก์ชนั่ switch...case (หลายทางเลือก)

ฟั งก์ชนั่ switch…case เป็ นฟั งก์ชนั่ หลายทางเลือกอีกฟังก์ชนั่ หนึ่ งที่มีการทางานคล้าย ๆ ฟั งก์ชนั่
if-else if…else ต่างตรงที่การตรวจสอบเงื่อนไขจะใช้การตรวจสอบการเท่ากันของตัวแปรที่ใช้ตรวจสอบ
เท่านั้น โดยเมื่อตรวจสอบค่าแล้วเท่ากับค่าที่กาหนดให้ทาฟังก์ชนั่ ที่เตรี ยมไว้
switch (variable)
{
case 1:
ตัวแปรที่ใช้ ตรวจสอบ // put code here for case 1
break;
case 2:
จริ ง ชุ ดฟังก์ชั่นเม่อ
เทากับคาที่ 1 // put code here for case 2
คาตัวแปรตรงกับ คาที่ 1 break;
เท็จ default:
จริ ง ชุ ดฟังก์ชั่นเม่อ // put code here for default
เทากับคาที่ 2 break;
คาตัวแปรตรงกับ คาที่ 2
เท็จ }
ชุ ดฟังก์ชั่นที่ตัวแปร
ตรวจสอบไมตรงกับ คาใด
ฟังก์ชั่นการดาเนินการแบบวนซ้า
การเขี ย นโปรแกรมสั่ ง งานไมโครคอนโทรลเลอร์ ต้องมี ก ารท างานแบบวนซ้ า หรื อวนรอบ
เพื่อที่ จะทางานในชุ ดคาสั่งเดิ ม ลักษณะการทางานมี ท้ งั แบบมี เงื่ อนไขหรื อไม่มีเงื่ อนไข ในภาษาซี มี
ฟังก์ชนั่ สั่งงานให้ไมโครคอนโทรลเลอร์ ทางานซ้ ามีดงั นี้
1. ฟังก์ชนั่ for
2. ฟังก์ชนั่ while
3. ฟังก์ชนั่ while(1)
4. ฟังก์ชนั่ do-while
ฟังก์ชนั่ for
ฟังก์ชนั่ for เป็ นฟังก์ชนั่ ที่ใช้ในกรณี ที่ทราบจานวนรอบที่จะทางานซ้ า โดยมีรูปแบบดังนี้
รู ปแบบ ผังงาน
for(ค่าเริ่ มต้น;เงื่อนไข;เพิ่มหรื อลดค่า )
{ คาตัวแปรนับ รอบเริ่มต้น
//ชุดฟังก์ชนั่ ที่ตอ้ งการทาซ้ า
เท็จ
} เง่ อนไข
จริ ง
ชุ ดฟังก์ชั่นที่ต้องการ
ทางานวนซ้ า
เพิ่ม/ลดตัวแปรนับ รอบ
โค้ ดโปรแกรม คาอธิบาย
for(int i=0;i<10;i++)
{ ประกาศและกาหนดตัวแปรนับรอบเป็ นตัวแปร i เป็ นตัว
delay(500); แปรชนิด integer โดยให้มีค่าเริ่ มต้นเท่ากับศูนย์ ทาวนซ้ า
delay(500); ไปเรื่ อย ๆ หากค่าตัวแปรยังน้อยกว่า 10 โดยในรอบถัดไป
}
ให้เพิ่มค่าในตัวแปรนับรอบขึ้น 1 ค่า
ฟังก์ชนั่ while
ฟังก์ชนั่ while เป็ นฟังก์ชนั่ ที่ให้ทางานวนซ้ าหรื อวนรอบโดยมีการตรวจสอบเงื่อนไขก่อนถ้าหาก
เงื่อนไขเป็ นจริ งจะทางานตามชุ ดฟังก์ชนั่ ที่เตรี ยมไว้ เมื่อทางานในชุดฟั งก์ชนั่ ที่เตรี ยมไว้เสร็ จจะมีการวน
กลับไปตรวจสอบเงื่ อนไขอีก หากเงื่ อนไขเป็ นจริ งจะทางานในชุ ดฟั งก์ชนั่ ที่เตรี ยมไว้โดยทาแบบนี้ ไป
เรื่ อย ๆ จนกว่าเงื่อนไขจะเป็ นเท็จจะออกจากวงรอบการทาซ้ า โดยมีรูปแบบดังนี้
while(เงื่อนไข )
{ เท็จ
เง่ อนไข
//ชุดฟังก์ชนั่ ที่ตอ้ งการทาซ้ า จริ ง
} ชุ ดฟังก์ชั่นที่ต้องการ
i=0;
while(i<10) ตรวจสอบก่ อนว่า เงื่ อนไขเป็ นจริ ง อยู่หรื อไม่ ( i ยังน้อย
{
digitalWrite(13,HIGH); กว่า 10 ) หากเงื่ อนไขเป็ นจริ งให้ทางานที่เตรี ยมไว้ เมื่อ
delay(500);
digitalWrite(13,LOW); ท างานครบให้ก ลับ มาตรวจสอบเงื่ อ นไขใหม่ ว นซ้ า ไป
delay(500);
i++; เรื่ อย ๆ จนกว่าเงื่อนไขจะเป็ นเท็จ
}
ฟังก์ชนั่ while(1)
ฟังก์ชนั่ while เป็ นฟังก์ชนั่ ที่ให้ทางานวนซ้ าหรื อวนรอบไม่รู้จบ เนื่องจาก 1 คือเป็ นจริ งตลอดไป
ในโปรแกรม Arduino ก็คือฟั งก์ชนั่ loop( ) นัน่ เอง
while(1)
{
//ชุดฟังก์ชนั่ ที่ตอ้ งการทาซ้ า ชุ ดฟังก์ชั่นที่ต้องการ
}
ฟังก์ชนั่ do-while
ฟั งก์ชนั่ do-while เป็ นฟั งก์ชนั่ ที่ให้ทางานวนซ้ าหรื อวนรอบ โดยมีการตรวจสอบเงื่ อนไขการ
ทางานคล้ายกับฟั งก์ชั่น while ต่างตรงที่ฟังก์ชั่น do-while จะทางานในชุ ดฟั งก์ชนั่ ที่เตรี ยมไว้ทาซ้ าไป
ก่อน 1 รอบแล้วจึงตรวจสอบเงื่อนไข
do
{ ชุ ดฟังก์ชั่นที่ต้องการ
//ชุดฟังก์ชนั่ ที่ตอ้ งการทาซ้ า ทางานวนซ้ า
} while(เงื่อนไข ) เท็จ
เง่ อนไข
จริ ง
i=0;
do ทางานในฟั งก์ชนั่ ที่เตรี ยมไว้ แล้วตรวจสอบเงื่อนไขว่าตัว
{
digitalWrite(13,HIGH); แปร i ยัง มี ค่ า น้อยกว่า 10 หรื อไม่ หากยังน้อยกว่าให้วน
delay(500);
digitalWrite(13,LOW); กลับไปทาใหม่ซ้ า ๆ จนกว่าเงื่อนไขจะเป็ นเท็จ
delay(500);
i++;
} while(i<10)
2.3 การสร้ างฟังก์ชั่นรองขึน้ ใช้ เอง

ฟั งก์ชั่นต่าง ๆ ที่ ได้กล่ าวมาแล้วเป็ นฟั งก์ชั่นที่ ภาษาซี มีให้ใช้งาน แต่ถ้าหากผูใ้ ช้งานต้องการ
ฟังก์ชนั่ ที่มีการทางานตามลักษณะเฉพาะส่ วนอย่างใดอย่างหนึ่งที่มีการเรี ยกใช้งานซ้ า ๆ หรื อเพื่อแยกงาน
ให้เป็ นส่ วน ๆ ให้ง่ายต่อการเขียนโปรแกรมสามารถเขียนขึ้นเพื่อใช้งานเองได้ การจัดวางตาแหน่ งของ
ฟังก์ชนั่ รองสามารถทาได้สองแบบคือ
1. วางกอนฟังก์ ชั่นที่เรียกใช้ งาน ตาแหน่งการวางลักษณะในนี้ ไม่ตอ้ งประกาศรู ปแบบของฟังก์ชนั่
(Prototype) ซึ่ งจะต้อ งวางฟั ง ก์ ชั่น รองต่ อ จากหัว โปรแกรมและก่ อ นฟั ง ก์ ชั่น setup การวาง
ลักษณะนี้ มีขอ้ ดี ตรงที่ ไม่ตอ้ งเขี ยนประกาศรู ปแบบ แต่จะทาให้ฟังก์ชั่นที่ ใช้งานหลัก (setup,
loop) ถูกดันลงไปท้าย ๆ โปรแกรมซึ่ งหากมีฟังก์ชนั่ รองหลาย ๆ ฟั งก์ชนั่ ยิ่งถูกดันไปล่าง ๆ ของ
โปรแกรมมากขึ้ น หากโปรแกรมมี ฟั ง ก์ ชั่น รองหลายสิ บ หลายร้ อ ยบรรทัด จะส่ ง ผลให้ ห า
โปรแกรมหลักเพื่อเขียนโปรแกรมยากขึ้นการแก้ไขโปรแกรมก็จะยากขึ้นตาม
2. วางหลังฟั งก์ ชั่นที่เรี ยกใช้ งาน ตาแหน่ งการวางลักษณะนี้ จะต้องประกาศรู ปแบบของฟั งก์ชนั่
(Prototype) ซึ่ งจะต้องมีเครื่ องหมาย ; ปิ ดท้ายด้วย โดยประกาศไว้ในท้ายของส่ วนหัวโปรแกรม
การวางลักษณะนี้มีขอ้ ดีตรงที่ฟังก์ชนั่ หลัก (setup, loop) ยังอยูต่ อนบนของโปรแกรมตลอดไม่วา่
จะมีฟังก์ชนั่ รองกี่ฟังก์ชนั่ ก็ตามทาให้การตรวจสอบแก้ไขปรับปรุ งในครั้งหลังทาได้สะดวก
หัวโปรแกรม ประกาศรู ปแบบฟังก์ชนั่ รอง
ตัวโปรแกรม ตัวโปรแกรม
ฟังก์ชนั่ รอง ฟังก์ชนั่ ที่ setup( )
ฟังก์ชนั่ ที่ setup( ) ฟังก์ชนั่ loop( )
ฟังก์ชนั่ loop( ) ฟังก์ชนั่ รอง
(วางก่อนฟังก์ชนั่ ที่เรี ยกใช้งาน) (วางหลังฟังก์ชนั่ ที่เรี ยกใช้งาน)

รู ปที่ 2-3 โครงสร้างการจัดวางฟังก์ชนั่ รองในภาษาซี
วางกอนฟังก์ชั่นที่เรียกใช้ งาน วางหลังฟังก์ชั่นทีเ่ รียกใช้ งาน
#define LED1 2 #define LED1 2
void pattern1(void) void pattern1(void);
{ void pattern2(void);
digitalWrite(LED1,HIGH); void pattern3(void);
digitalWrite(LED2,LOW); void setup()
digitalWrite(LED3,LOW); {
} pinMode(LED1,OUTPUT);
void pattern2(void) pinMode(LED2,OUTPUT);
{ pinMode(LED3,OUTPUT);
digitalWrite(LED1,LOW); }
digitalWrite(LED2,HIGH); void loop()
digitalWrite(LED3,LOW); {
} pattern1(); delay(200);
void pattern3(void) pattern2(); delay(200);
{ pattern3(); delay(200);
digitalWrite(LED1,LOW); }
digitalWrite(LED2,LOW); void pattern1(void){
digitalWrite(LED3,HIGH); digitalWrite(LED1,HIGH);
} digitalWrite(LED2,LOW);
void setup() digitalWrite(LED3,LOW);
{ }
pinMode(LED1,OUTPUT); void pattern2(void){
pinMode(LED2,OUTPUT); digitalWrite(LED1,LOW);
pinMode(LED3,OUTPUT); digitalWrite(LED2,HIGH);
} digitalWrite(LED3,LOW);
void loop() }
{ void pattern3(void){
pattern1(); delay(200); digitalWrite(LED1,LOW);
pattern2(); delay(200); digitalWrite(LED2,LOW);
pattern3(); delay(200); digitalWrite(LED3,HIGH);
} }
ฟังก์ชนั่ รองที่เขียนขึ้นใช้เองมีดว้ ยกัน 4 ประเภทคือ

- ฟังก์ชนั่ ที่ไม่รับค่าและไม่ส่งคืนค่า
- ฟังก์ชนั่ ที่รับค่าแต่ไม่ส่งคืนค่า
- ฟังก์ชนั่ ที่ไม่รับค่าแต่ส่งคืนค่า
- ฟังก์ชนั่ ที่รับค่าและส่ งคืนค่า
ฟังก์ชนั่ ที่ไม่รับค่าและไม่ส่งคืนค่า
เป็ นฟั งก์ชนั่ รองที่เขียนขึ้นโดยการรวมชุ ดฟั งก์ชนั่ เพื่อให้ทางานอย่างหนึ่ งอย่างใดเป็ นอิสระจาก
ฟั งก์ชนั่ หลักไม่มีการรับค่าใด ๆ จากฟั งก์ชนั่ หลักเพื่อนาใช้งานในตัวของฟั งก์ชนั่ รอง และไม่มีการส่ งค่า
ใด ๆ กลับมายังฟั งก์ชนั่ หลักที่เป็ นผูเ้ รี ยกใช้งาน ซึ่ งข้อกาหนดในการประกาศใช้ของฟั งก์ชนั่ ประเภทนี้มี
ดังนี้
1. ข้อกาหนดในการไมรับคา ทาโดยใส่ (void) หลังชื่ อฟังก์ชนั่
2. ข้อกาหนดในการไมสงคนคา ทาโดยใส่ void หน้าชื่ อฟังก์ชนั่
ตัวอย่างโปรแกรมที่มีฟังก์ชนั่ รองที่ไม่รับค่าและไม่ส่งคืนค่า void pattern1(void);
1 #define LED1 2
2 #define LED2 3
3 #define LED3 4
4 void pattern1(void);
7 void setup()
8 {
9 pinMode(LED1,OUTPUT);
12 }
13 void loop()
14 {
15 pattern1(); delay(200);
18 }
19 void pattern1(void)
20 {
21 digitalWrite(LED1,HIGH);
22 digitalWrite(LED2,LOW);
24 }
26 {
30 }
32 {
36 }
รายละเอียดโค้ ดโปรแกรม
- บรรทัดที่ 4, 5, 6 เป็ นการประกาศรู ปแบบของฟั งก์ชนั่ รองที่จะเขียนขึ้นใช้งาน (มี ; ปิ ดท้าย) และ
เป็ นฟังก์ชนั่ ที่ไม่รับค่าและไม่ส่งคืนค่า (มี void หน้าฟังก์ชนั่ และหลังฟังก์ชนั่ )
- บรรทัดที่ 14, 15, 16 เป็ นการเรี ยกใช้งานโดยการชื่ อฟั งก์ชนั่ ที่ตอ้ งการตามด้วย ( ) ที่ภายในว่าง
เปล่าเนื่องจากไม่มีการส่ งค่าเข้าในฟังก์ชนั่
- บรรทัดที่ 19-24 เป็ นฟังก์ชนั่ รองฟังก์ชนั่ แรกที่เขียนขึ้นใช้งานโดยภายในบรรจุฟังก์ชนั่ ที่ตอ้ งการ
ให้ทางานเมื่อมีการเรี ยกใช้
- บรรทัดที่ 25-30, บรรทัดที่ 25-30, บรรทัดที่ 31-36 เป็ นฟังก์ชนั่ รองถัด ๆ มาที่เขียนขึ้นใช้งาน
ฟังก์ชนั่ ที่รับค่าแต่ไม่ส่งคืนค่า
เป็ นฟั งก์ชนั่ ที่เขียนขึ้นเพื่อแบ่งย่อยการทางานของฟั งก์ชนั่ หลัก โดยมีการส่ งค่าจากฟั งก์ชนั่ หลัก
ในขั้นตอนการเรี ยกใช้ฟังก์ชนั่ รองเพื่อให้ฟังก์ชนั่ รองที่เขียนขึ้นนาไปประมวลผลอย่างใดอย่างหนึ่งตามที่
ผูส้ ร้างฟังก์ชนั่ ต้องการ ซึ่ งข้อกาหนดในการประกาศใช้ของฟังก์ชนั่ ประเภทนี้มีดงั นี้
1. ข้อกาหนดในการรับคา ทาโดยกาหนดชนิ ดตัวแปร พร้อมตัวแปรที่จะรับค่าท้ายชื่ อฟั งก์ชนั่
รองที่สร้างขึ้น เช่น (byte data)
2. ข้อกาหนดในการไมสงคนคา ทาโดยใส่ void หน้าชื่อฟังก์ชนั่
ตัวอย่างโปรแกรมที่มีฟังก์ชนั่ รองที่รับค่าและไม่ส่งคืนค่า void send2port(byte data);

1 #define LED1 2
2 #define LED2 3
3 #define LED3 4
4 #define LED4 5
5 char LED_pin[] = {LED1,LED2,LED3,LED4};
6 void send2port(byte data);
7 void setup()
8 {
9 Serial.begin(9600);
10 for(char i=0;i<4;i++)
11 {
12 pinMode(LED_pin[i],OUTPUT);
13 }
14 }
15 void loop()
16 {
17 send2port(0B1000);delay(200);
21 }
22 void send2port(byte data)
23 {
24 if (data & 1 ){digitalWrite(LED_pin[0],HIGH);} else {digitalWrite(LED_pin[0],LOW);}
28 }
- บรรทัดที่ 6 เป็ นการประกาศรู ป แบบของฟั งก์ชั่นรองที่ จะเขี ย นขึ้ นใช้งาน (มี ; ปิ ดท้าย) เป็ น
ฟั งก์ชนั่ ที่ไม่มีการส่ งคืนค่า (มี void อยูห่ น้าฟั งก์ชนั่ ) แต่เป็ นฟั งก์ชนั่ ที่รับค่าเพียงอย่างเดียว โดย
ในวงเล็บหลังฟั งก์ชนั่ จะเป็ นตัวแปรที่ใช้สาหรับรับค่าซึ่ งจะต้องประกาศชนิ ดของตัวแปรพร้อม
ชื่อตัวแปรสาหรับรับค่าไว้ในวงเล็บท้ายฟังก์ชนั่
- บรรทัด 17-20 เป็ นการเรี ยกใช้ฟังก์ชั่นรองโดยการเรี ยกชื่ อฟั งก์ชั่นรองพร้ อมส่ งค่า เข้าไปใน
ฟั งก์ชนั่ โดยค่าที่ส่งไปจะใส่ ในวงเล็บท้ายชื่ อฟั งก์ชนั่ รองที่เรี ยกใช้ ค่าที่ส่งไปจะเข้าไปเก็บไว้ใน
ตัวแปรที่ ฟังก์ชั่นรองประกาศไว้ เช่ น send2port(0B1000); เป็ นการเรี ยกใช้ฟังก์ชั่น send2port
โดยส่ งค่าตัวเลข 1000 ซึ่ งเป็ นเลขฐานสองเข้าไปในฟั งก์ชนั่ รองนั้นด้วย ค่าตัวเลขดังกล่าวจะถูก
เก็บไว้ในตัวแปร data ซึ่ งฟังก์ชนั่ รองได้เตรี ยมเอาไว้
- บรรทัดที่ 20-28 เป็ นฟั งก์ชนั่ รองที่เขียนขึ้น ภายในฟั งก์ชนั่ มีการนาค่าที่ถูกส่ งเข้ามาผ่านตัวแปร
data นามาใช้งาน
ฟังก์ชนั่ ที่ไม่รับค่าแต่ส่งคืนค่า
เป็ นฟั ง ก์ชั่นที่ เขี ย นขึ้ นเพื่ อแบ่ ง ย่อยการท างานของฟั ง ก์ชั่น หลัก เพี ย งแต่ ไ ม่ ไ ด้ส่ ง ข้อมู ล เข้า
โปรแกรมเพื่อช่วยให้ทาการประมวลผลแต่มีการส่ งข้อมูลกลับมายังฟั งก์ชนั่ หลัก เช่นฟั งก์ชนั่ ตรวจสอบ
การกดสวิตช์ซ่ ึ งฟั งก์ชนั่ นี้ ไม่จาเป็ นต้องรั บข้อมู ลใดมาประมวลผลมี เพียงตรวจสอบว่ามีการกดสวิตช์
หรื อไม่แล้วส่ งค่าการกดสวิตช์กลับไปยังฟั งก์ชนั่ หลักเพื่อนาไปใช้งานต่อไป โดยค่าที่ ส่งกลับผูเ้ ขียน
โปรแกรมจะเป็ นผูก้ าหนดขึ้นมาเอง เช่น เมื่อสวิตช์ 1 ถูกกดให้ส่งค่า 1 กลับและเมื่อสวิตช์ 2 ถูกกดให้ส่ง
ค่า 2 หากไม่มีการกดใด ๆ ให้ส่งกลับค่า 0 เป็ นต้น
การเขียนฟังก์ชนั่ รองลักษณะนี้มีขอ้ กาหนดในการประกาศใช้ของฟังก์ชนั่ ดังนี้
1. ข้อกาหนดในการไมรับคา ทาโดยใส่ (void) หลังชื่ อฟังก์ชนั่
2. ข้อกาหนดในการสงคนคา ทาโดยใส่ กาหนดชนิ ดของข้อมูลที่จะส่ งคืนหน้าชื่อฟังก์ชนั่ รอง
ที่สร้างขึ้น
ตัวอย่างโปรแกรมที่มีฟังก์ชนั่ รองที่ไม่รับค่าแต่ส่งคืนค่า byte readSW(void);

1 #define LED 2
2 #define SW1 3
3 #define SW2 4
4 byte readSW(void);
5 void setup()
6 {
7 pinMode(LED,OUTPUT);
8 pinMode(SW1,INPUT_PULLUP);
9 pinMode(SW2,INPUT_PULLUP);
10 }
11 void loop()
12 {
13 byte x=readSW();
14 if(x==1)
15 digitalWrite(LED,HIGH);
16 else if(x==2)
17 digitalWrite(LED,LOW);
18 }
19 byte readSW(void)
20 {
21 byte Status=0;
22 if(digitalRead(SW1)==LOW)
23 Status=1;
24 else if(digitalRead(SW2)==LOW)
25 Status=2;
26 return Status;
27 }
- บรรทัดที่ 4 เป็ นการประกาศรู ปแบบของฟังก์ชนั่ รอง byte readSW(void); ซึ่งเป็ นฟังก์ชนั่ ที่มีการ
ส่ งค่ากลับคืนฟังก์ชนั่ หลัก โดยค่าที่ส่งกลับมีขนาดเป็ นค่าของตัวแปร byte
- บรรทัดที่ 13 เป็ นการเป็ นการเรี ยกใช้ฟังก์ชนั่ รอง byte x=readSW(); เมื่อฟั งก์ชนั่ รองทางานเสร็ จ
สิ้ นจะส่ งค่าเข้ามายังตัวแปร x ซึ่ งเป็ นตัวแปรได้ประกาศชนิ ดที่มีขนาดที่เพียงพอที่สามารถรับ
ข้อมูลที่ส่งกลับมาจากฟังก์ชนั่ รองนี้ได้
- บรรทัด 19-27 เป็ นฟังก์ชนั่ รองที่เขียนขึ้นเพื่อใช้งานที่มีการส่ งค่าคืนไปยังฟังก์ชนั่ หลัก
- บรรทัดที่ 21 การประกาศตัวแปรที่มีชนิดเดียวกันกับค่าที่ฟังก์ชนั่ รองส่ งออก
- บรรทัดที่ 26 ฟั งก์ชนั่ return เป็ นฟั งก์ชนั่ ที่ใช้สาหรับส่ งค่าออกจากฟั งก์ชนั่ รอง โดยค่าที่ส่งออก
จะอยู่ในตัวแปรท้ายฟั งก์ชั่น return ซึ่ งมี ขนาดเดี ยวกันกับชนิ ดของค่าที่ ประกาศของฟั ง ก์ ชั่น
(หน้าชื่อฟังก์ชนั่ รอง)
ฟังก์ชนั่ ที่รับค่าและส่ งคืนค่า

เป็ นฟั งก์ชนั่ ที่เขียนขึ้นเพื่อแบ่งย่อยการทางานของฟั งก์ชนั่ หลักโดยมีการส่ งค่าจากฟั งก์ชนั่ หลัก
เพื่อให้ฟังก์ชั่นรองที่ เขียนขึ้ นนาไปประมวลค่าอย่างใดอย่างหนึ่ งและส่ งค่ากลับมายังฟั งก์ชนั่ หลัก ซึ่ ง
ฟั งก์ชนั่ รองชนิ ดนี้ มกั ใช้บ่อยเมื่อต้องการสร้างกลุ่มฟั งก์ชนั่ ที่ตอ้ งการคานวณสิ่ งใดสิ่ งหนึ่ งโดยมีขอ้ มูลที่
ใช้ในการคานวณนั้น ๆ ด้วย และเมื่อคานวณเสร็ จสิ้ นฟั งก์ชนั่ หลักมีความต้องการผลการคานวณนั้นด้วย
เช่น ฟังก์ชนั่ แปลงค่าจากการอ่านค่าจากเทอร์ มิสเตอร์ NTC และต้องการผลเป็ นอุณหภูมิ ซึ่ งข้อกาหนดใน
การประกาศใช้ของฟังก์ชนั่ ประเภทนี้มีดงั นี้
1. ข้อกาหนดในการรับคา ทาโดยกาหนดชนิดตัวแปร พร้อมตัวแปรที่จะรับค่าท้ายชื่ อฟังก์ชนั่
รองที่สร้างขึ้น เช่น (int x)
2. ข้อกาหนดในการสงคนคา ทาโดยใส่ กาหนดชนิ ดของข้อมูลที่จะส่ งคืนหน้าชื่อฟังก์ชนั่ รอง
ตัวอย่างโปรแกรมที่มีฟังก์ชนั่ รองที่รับค่าและส่ งคืนค่า double Thermistor(int RawADC);

1 #define NTC A5
2 double Thermistor(int RawADC);
3 void setup()
4 {
6 }
7 void loop()
8 {
9 float Temp=Thermistor(analogRead(NTC));
10 Serial.print("Temperature is : ");
Serial.print(Temp);
11 Serial.println(" 'C");
12 delay(1000);
13 }
14 double Thermistor(int RawADC)
15 {
16 double Cal;
17 Cal = log(10000.0/((1024.0/RawADC-1)));
18 Cal = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Cal * Cal ))* Cal );
19 Cal = Cal - 273.15; // Convert Kelvin to Celcius
20 return Cal;
21 }
- บรรทัดที่ 2 เป็ นการประกาศรู ปแบบของฟั งก์ชนั่ รอง double Thermistor(int RawADC); ที่จะ
เขียนขึ้นใช้งาน (มี ; ปิ ดท้าย) เป็ นฟั งก์ชนั่ ที่มีการรับค่าและส่ งค่ากลับคืนฟั งก์ชนั่ หลัก โดยค่าที่
รับจะถูกเก็บไว้ในตัวแปรชื่อ RawADC ถูกกาหนดให้เป็ นชนิด integer และส่ งคืนค่ากลับมีขนาด
เป็ นค่าของตัวแปร double
- บรรทัดที่ 9 เป็ นการเรี ยกใช้ฟังก์ชนั่ รอง float Temp=Thermistor(analogRead(NTC)); โดยส่ งค่า
เข้าฟั งก์ชนั่ รองในวงเล็บ หลังชื่ อฟั งก์ชั่น และประกาศตัวแปรไว้รับค่ า (Temp) ที่ได้จากการ
ส่ งกลับจากฟั งก์ชนั่ รอง จากตัวอย่างจะเห็ นว่าใช้ตวั แปรที่ใช้รับค่ามีขนาดเล็กกว่าค่าที่ส่งกลับ
ดังนั้นจะมีขอ้ มูลหายไปบางส่ วน แต่ถา้ หากผูเ้ ขียนโปรแกรมยอมรับการสู ญหายของข้อมูลนั้น
ได้โดยผลการทางานของโปรแกรมยังเท่าเดิมก็สามารถทาได้
- บรรทัดที่ 14-21 เป็ นฟั งก์ชนั่ รองที่เขียนขึ้นมาเพื่อประมวลผลตามต้องการที่มีการรั บค่าเข้ามา
คานวณและส่ งค่ากลับคืนยังฟังก์ชนั่ หลัก
2.4 ขอบเขตของตัวแปร
ขอบเขตของตัวแปรหมายถึงบริ เวณหรื อตาแหน่งหรื อพิกดั ของตัวแปรที่ฟังก์ชนั่ สามารถเรี ยกใช้
งานได้ ทั้งนี้ข้ ึนอยูก่ บั ตัวแปรตัวนั้น ๆ ว่าประกาศไว้ที่จุดใด โดยขอบเขตของตัวแปรมีดว้ ยกัน 2 แบบ
1. ตัวแปรประเภทโกลบอล (global) เป็ นตัวแปรที่ประกาศนอกฟั งก์ชนั่ ซึ่ งจะประกาศไว้ใน
ส่ วนของหัวโปรแกรม ตัวแปรเหล่านี้ สามารถถูกนาไปใช้งานได้ทุกฟั งก์ชนั่ หรื ออาจกล่าว
ได้วา่ ทุกฟังก์ชนั่ สามารถมองเห็นตัวแปรประเภทนี้
2. ตัวแปรประเภทโลคอล (local) เป็ นตัวแปรที่ประกาศภายในฟั งก์ชนั่ ซึ่ งสามารถใช้งานได้

เฉพาะภายในฟังก์ชนั่ ที่ประกาศเท่านั้นนอกฟังก์ชนั่ ไม่สามารถใช้งานได้ หรื ออาจกล่าวได้วา่
ตัวแปรโลคอลมองเห็นเฉพาะภายในเท่านั้น
ตัวอย่างการประกาศตัวแปรในขอบเขตที่ต่างกัน
1 byte LED1=2;
2 byte LED2=3;
3 void setup()
4 {
7 }
8 void loop()
9 {
10 int i;
11 for(i=0;i<10;i++)
12 {
13 digitalWrite(LED1,HIGH);delay(100);
14 digitalWrite(LED1,LOW);delay(100);
15 }
16 for(i=0;i<10;i++)
17 {
18 digitalWrite(LED2,HIGH);delay(100);
19 digitalWrite(LED2,LOW);delay(100);
20 }
21 }
- บรรทัดที่ 1,2 เป็ นการประกาศตัวแปร LED1, LED2 ซึ่ งประกาศอยูน่ อกฟังก์ชนั่ เป็ นการประกาศ
ตัวแปรในตาแหน่งโกลบอล นัน่ หมายความว่าทุกฟั งก์ชนั่ จะสามารถใช้ (มองเห็น) ตัวแปรนี้ ได้
สามารถนาไปใช้ง านได้ เช่ นในฟั ง ก์ชั่น setup ได้นาไปก าหนดโหมดการท างานในฟั งก์ชั่น
pinMode และในฟังก์ชนั่ loop ได้นาไปใช้ในฟังก์ชนั่ digitalWrite
- บรรทัดที่ 10 เป็ นการประกาศตัว แปร i ซึ่ ง จะนาไปใช้นับ รอบในค าสั่ ง forโดยตัวแปรนี้ จะ
มองเห็ นและใช้งานได้เฉพาะภายในฟั งก์ชนั่ loop เท่านั้น นอกฟั งก์ชนั่ (เช่ นฟั งก์ชนั่ setup ใน
ตัวอย่าง) ไม่สามารถใช้งานตัวแปรนี้ได้ หรื อกล่าวได้วา่ มองไม่เห็นตัวแปร i นี้
2.5 การประกาศตัวแปรแบบสตรัคเจอร์ (Structure) และยูเนียน (Union)

การใช้งานตัวแปรที่มีจานวนตัวแปรมาก ๆ อาจเกิดการสับสนในการใช้งานได้ ภาษาซี สามารถ
จัดรวมกลุ่มตัวแปรเพื่อให้เกิดความสะดวกต่อการเรี ยกใช้งานได้ ซึ่ งตัวแปรที่นามารวมกลุ่มนั้นสามารถ
รวมกลุ่มตัวแปรที่เป็ นชนิดแตกต่างกันได้ โดยมีวธิ ีการประกาศด้วยกัน 2 แบบคือ
1. แบบสตัคเจอร์ (Structure)
2. แบบยูเนียน (Union)
โดยในแต่ละแบบมีคุณสมบัติในการจัดการที่แตกต่างกัน
การประกาศตัวแปรแบบสตัคเจอร์ (Structure)
เป็ นการประกาศตัวแปรที่สามารถรวมกลุ่มของข้อมูลได้หลายชนิ ดไม่ว่าจะเป็ นตัวเลขจานวน
เต็ม ตัวเลขที่เป็ นทศนิ ยมหรื อเป็ นตัวอักษรก็ตาม โดยสามารถใช้งานได้ในเวลาเดียวกันเนื่ องจากตัวแปร
ย่อย ๆ ภายในสตัคเจอร์ ได้ถูกแยกพื้นที่หน่วยความจาสาหรับการเก็บข้อมูล วิธีการประกาศมีรูปแบบดังนี้
การประกาศ
struct ชื่อตัวแปรสตัคเจอร์
{
ชนิดตัวแปร ชื่อตัวแปรตัวที่ 1;
---
};
การใช้ งาน
ชื่อตัวแปรสตัคเจอร์ ชื่อตัวแปรใหม่ที่ตอ้ งการตั้งชื่อ={ค่าเริ่ มต้นของตัวแปรตัวที่ 1, 2, …};
ตัวอยางเชน
1 struct VALUE
2 {
3 byte a;
4 int b;
5 float c;
6 };
7 VALUE data={123,12345,123.45};
8 void setup()
9 {
11 Serial.println(data.a);
12 Serial.println(data.b);
13 Serial.println(data.c);
14 }
15 void loop()
16 {
17 }
- บรรทัดที่ 1-6 เป็ นการประกาศตัวแปรแบบสตัคเจอร์ โดยตั้งชื่ อว่า VALUE มีตวั แปรภายใน 3 ตัว
ที่เก็บข้อมูลแตกต่างกัน
- บรรทัดที่ 7 เป็ นการกาหนดค่าเริ่ มต้นโดยสามารถเปลี่ ยนชื่ อเรี ยกใหม่ได้ ในที่น้ ี เปลี่ ยนชื่ อจาก
VALUE เป็ นชื่ อว่า data และสามารถกาหนดค่าเริ่ มต้นเข้าไปในทุกตัวแปรภายในได้ในขั้นตอน
นี้ จากตัวอย่างกาหนดตัวแปร data.a=123 ตัวแปร data.b=12345 และตัวแปร data.c=123.45
ผลการรันเป็ นดังรู ป
รู ปที่ 2-4 ผลการรันโปรแกรมที่ใช้งานตัวแปรแบบสตัคเจอร์
การประกาศตัวแปรแบบยูเนียน (Union)
เป็ นการประกาศตัวแปรที่สามารถรวมกลุ่มของข้อมูลได้หลายชนิ ดเช่นเดียวกับแบบสตัคเจอร์
แต่มีความแตกต่างตรงที่แบบยูเนี ยนใช้หน่วยความจาเก็บข้อมูลในตาแหน่งเดียวกันในทุกตัวแปรดังนั้น
เวลาใช้งานจึงไม่สามารถใช้พร้ อมกันได้ เนื่ องจากตัวแปรที่กาหนดค่าตัวหลังสุ ดจะเป็ นตัวที่ได้ใช้งาน
หน่วยความจาในตาแหน่งนั้น ๆ ทาให้ขอ้ มูลในตัวแปรแรก ๆ ถูกแทนที่ไปด้วยค่าในตัวแปรล่าสุ ดแทน
รู ปแบบการประกาศดังนี้
การประกาศ
union ชื่อตัวแปรยูเนียน
{
---
};
การใช้ งาน
ชื่อตัวแปรยูเนียน ชื่อตัวแปรใหม่ที่ตอ้ งการตั้งชื่อ;
1 union VALUE
2 {
3 byte a;
4 int b;
5 float c;
6 };
7 VALUE data;
8 void setup()
9 {
11 data.a=123; Serial.println(data.a);
12 data.b=12345; Serial.println(data.b);
13 data.c=123.45; Serial.println(data.c);
14 }
15 void loop()
16 {
17 }
- บรรทัดที่ 1-6 เป็ นการประกาศตัวแปรแบบยูเนี ยนโดยตั้งชื่ อว่า VALUE มีตวั แปรภายใน 3 ตัวที่
เก็บข้อมูลแตกต่างกัน
- บรรทัดที่ 7 เป็ นการกาหนดชื่ อเรี ยกใหม่ในที่ น้ ี เปลี่ ยนชื่ อจาก VALUE เป็ นชื่ อว่า data แต่ไม่
สามารถกาหนดค่าเริ่ มต้นแบบตัวแปรสตรัคเจอร์ ได้
- บรรทัดที่ 11 เป็ นการกาหนดค่าให้กบั ตัวแปรตัวแรก data.a พร้อมนาไปใช้งานทันที โดยตัวอย่าง
ดังกล่าวเป็ นการนาส่ งข้อมูลออกทางพอร์ ตอนุกรมเพื่อแสดงผลหน้าจอคอมพิวเตอร์
- บรรทัดที่ 12 เป็ นการกาหนดค่าให้กบั ตัวแปรตัวแรก data.b ค่าของตัวแปรนี้ จะไปทับข้อมูลของ
data.a ซึ่ งตอนนี้ไม่ได้ใช้งานแล้ว
- บรรทัดที่ 13 เป็ นการกาหนดค่าให้กบั ตัวแปรตัวแรก data.c ค่าตัวแปรนี้ จะไปทับข้อมูลของตัว
แปร data.b เนื่องจากใช้ตาแหน่งของหน่วยความจาเดียวกันในการเก็บข้อมูล
รู ปที่ 2-5 ผลการรันโปรแกรมที่ใช้งานตัวแปรแบบยูเนียน

หากกาหนดค่าตัวแปรต่อเนื่องกัน ตัวแปรตัวสุ ดท้ายจะไปทับข้อมูลตัวแปรตัวแรก ๆ ของตัวแปรยูเนียน

1 union VALUE
2 {
3 byte a;
4 int b;
5 float c;
6 };
7 VALUE data;
8 void setup()
9 {
10 data.a=123;
11 data.b=12345;
12 data.c=123.45;
14 Serial.println(data.a);
15 Serial.println(data.b);
16 Serial.println(data.c);
17 }
18 void loop()
19 {
20 }
รู ปที่ 2-6 ผลการรันโปรแกรมที่ใช้งานตัวแปรแบบยูเนียนที่กาหนดค่าตัวแปรพร้อมกัน

บทที่ 3 เครื่ องมือช่วยงานไมโครคอนโทรลเลอร์ Arduino  45
บทที่ 3
เครื่ องมือช่ วยงานไมโครคอนโทรลเลอร์ Arduino
3.1 เครื่ องมือแปลงภาษาซีเป็ นภาษาเครื่ องและอัพโหลดไฟล์ลงชิพ
3.2 ไดร์ฟเวอร์ USB
3.3 เครื่ องมือจาลองการทางาน
เครื่ องมือช่วยพัฒนางานไมโครคอนโทรลเลอร์ เป็ นเครื่ องมืออานวยความสะดวกทาให้สามารถ
พัฒนางานได้ง่ า ยและเร็ ว เครื่ องมื อที่ นามาใช้งานมี 3 อย่า งด้วยกัน คื อ เครื่ องมื อ แปลงภาษาซี เ ป็ น
ภาษาเครื่ องพร้อมอัพโหลดลงชิพ เครื่ องมือจาลองการทางาน และไดร์ฟเวอร์ USB
รู ้และเข้าใจการใช้งานและสามารถใช้เครื่ องมือช่วยพัฒนางานไมโครคอนโทรลเลอร์
1. เพื่อให้มีความรู ้เกี่ยวกับเครื่ องมือแปลงภาษาซีเป็ นภาษาเครื่ องและอัพโหลดไฟล์ลงชิพ
2. เพื่อให้มีความรู ้เกี่ยวกับเครื่ องมือจาลองการทางาน
3. เพื่อให้มีความรู ้เกี่ยวกับการติดตั้งไดร์ ฟเวอร์ USB
1. บอกเกี่ยวกับเครื่ องมือแปลงภาษาซีเป็ นภาษาเครื่ องและอัพโหลดไฟล์ลงชิพได้
2. บอกเกี่ยวกับเครื่ องมือจาลองการทางานได้
3. บอกขั้นตอนการติดตั้งไดร์ ฟเวอร์ USBได้
เครื่ องมือช่ วยงานไมโครคอนโทรลเลอร์ Arduino

การพัฒนาไม่ว่าจะเป็ นการพัฒนาในเรื่ องใดก็ตามหากมีเครื่ องมือช่วยพัฒนางานที่มีคุณภาพจะ
ทาให้งานนั้น ๆ สามารถพัฒนาไปได้เร็ วและจะส่ งผลให้ผพู ้ ฒั นางานสามารถใช้ความสามารถได้เต็มที่
สาหรับไมโครคอนโทรลเลอร์ ในแพลทฟอร์ม Arduino มีเครื่ องมือช่วยพัฒนางาน 3 ชนิด คือ
1. เครื่ องมือแปลงภาษาซีเป็ นภาษาเครื่ องและอัพโหลดไฟล์ลงชิพ
2. ไดร์ฟเวอร์ USB
3. เครื่ องมือจาลองการทางาน
3.1 เครื่ องมือแปลงภาษาซีเป็ นภาษาเครื่ องและอัพโหลดไฟล์ลงชิพ
เครื่ องมือที่ใช้แปลงภาษาซี เป็ นภาษาเครื่ องหรื อที่เรี ยกกันว่า ซี คอมไพเลอร์ (C Compiler) เป็ น
โปรแกรมคอมพิวเตอร์ ชนิดหนึ่งที่ถูกสร้างขึ้นเพื่อใช้สาหรับแปลงภาษาซี เป็ นภาษาเครื่ อง โปรแกรมที่ถูก
ออกแบบมาให้ใช้งานกับ Arduino คือโปรแกรม Arduino IDE การติดตั้งและการใช้งานมีดงั นี้
การติดตั้งโปรแกรม Arduino IDE

Arduino IDE เป็ นโปรแกรมสาหรับเขียนโค้ดเพื่อควบคุมการทางานของไมโครคอนโทรลเลอร์
Arduino ซึ่ งตัว โปรแกรมมี ใ ห้ ด าวน์ โ หลดให้ ใ ช้ ง านได้โ ดยไม่ มี ค่ า ใช้ จ่ า ยและมี เ วอร์ ชั่น ที่ ร องรั บ
ระบบปฏิบตั ิการหลายแบบ เอกสารเล่มนี้ ขอแนะนาเฉพาะโปรแกรมที่รองรับระบบปฏิบตั ิการวินโดวส์
เท่านั้น โดยขั้นตอนมีดงั นี้
1. ดาวน์โหลดโปรแกรมโดยเข้าไปที่เวปไซด์ https://www.arduino.cc/en/Main/Software คลิก

ที่คาว่า SOFTWARE ดังรู ป
รู ปที่ 3-1 หน้าต่างเวปไซต์สาหรับดาวน์โหลดโปรแกรม Arduino IDE
2. เลือกดาวน์โหลดไฟล์ที่เป็ นไฟล์ zip (เพื่อให้ง่ายต่อการอัพเดจหรื อถอนโปรแกรมออกใน

อนาคต) โดยคลิกตรงคาว่า Windows ZIP file for non admin install ดังรู ป
รู ปที่ 3-2 บริ เวณที่สาหรับคลิกเพื่อดาวน์โหลดไฟล์ zip
3. คลิกตรงคาว่า JUST DOWNLOAD เพื่อดาวน์โหลดไฟล์
รู ปที่ 3-3 หน้าต่างเวปไซต์สาหรับคลิกเพื่อดาวน์โหลด
4. แตกไฟล์แล้วคัดลอกทั้งโฟลเดอร์ มาไว้ที่ไดร์ ฟ C ดังรู ป
รู ปที่ 3-4 คัดลอกทั้งโฟลเดอร์ มาไว้ที่ไดร์ ฟ C
การใช้ งานโปรแกรม Arduino IDE

การใช้ง านโปรแกรม Arduino IDE เพื่ อเขี ย นโค้ดโปรแกรมควบคุ มการท างานของ Arduino
สามารถใช้ประโยชน์ได้ 2 แนวทางคือ
1. เพื่อนาไฟล์ภาษาเครื่ องที่ได้จากการแปลงไปจาลองการทางานด้วยโปรแกรม Proteus
2. เพื่อทดลองวงจรจริ ง (ซึ่ งต้องติดตั้งไดร์ ฟเวอร์ USB ก่อน)
การใช้งานโปรแกรม Arduino IDE มีข้ นั ตอนดาเนินการดังนี้

1. เรี ยกใช้โปรแกรมด้วยการดับเบิลคลิกไฟล์ Arduino.exe ในโฟลเดอร์ โปรแกรมที่ได้แตก
ไฟล์ไว้
2. ตั้งค่าบอร์ ดให้ตรงกับที่ใช้งานซึ่ งมีการตั้งค่าอยูด่ ว้ ยกัน 4 รายการดังนี้
- ชนิดของบอร์ ด Arduino ที่ใช้งาน (กาลังเชื่อมต่ออยู)่
- ชนิดของโพรเซสเซอร์ เลือกให้ตรงกับโพรเซสเซอร์ ของบอร์ ด (บอร์ ดบางชนิดไม่ตอ้ ง
เลือกเนื่องจากมีใช้งานเพียงเบอร์ เดียว)
- คอมพอร์ ตที่กาลังเชื่ อมต่อ เลือกให้ตรงกับที่บอร์ ด Arduino กาลังเชื่อมต่อ (ดูจาก
Device manager)
- ชนิดของเครื่ องโปรแกรม เลือก AVRISP mkII
รู ปที่ 3.5 การตั้งค่าบอร์ ดที่ใช้งาน
3. ตั้งค่าในโปรแกรม Arduino IDE ให้แสดงตาแหน่งของไฟล์ภาษาเครื่ อง (HEX file) หลังจาก

การคอมไพล์ผา่ น การตั้งค่าดังรู ป
รู ปที่ 3-6 คลิก Preferences

4. คลิกเลือกแสดงผลทั้ง 3 รายการดังรู ป
รู ปที่ 3-7 คลิกเลือกทั้ง 3 รายการ
5. เขียนโค้ดโปรแกรมที่ตอ้ งการในหน้าต่างโปรแกรม
6. ในกรณี ที่ตอ้ งการคอมไพล์เพื่ อดู ผ ลของการเขี ยนโปรแกรมว่า ถู กไวยกรณ์ หรื อไม่ หรื อ
ต้องการไฟล์ภาษาเครื่ อง (HEX file) ไปจาลองการทางานในโปรแกรมจาลองการทางาน เมื่อ
เขียนโค้ดโปรแกรมเสร็ จสิ้ นแล้วให้คลิกที่ปุ่มคอมไพล์
รู ปที่ 3-8 คลิกปุ่ มคอมไพล์หลังเขียนโค้ดโปรแกรมเสร็ จสิ้ น
7. ในกรณี ที่ตอ้ งการไฟล์ภาษาเครื่ องไปจาลองการทางาน ให้คดั ลอกตาแหน่งไฟล์ภาษาเครื่ อง

ในบริ เวณหน้าต่างผลการคอมไพล์ (พื้นสี ดา) โดยใช้เมาส์ คลุ มดาบริ เวณที่อยู่ไฟล์แล้วกด
คียบ์ อร์ ด Ctrl+C ตาแหน่ งของไฟล์จะถู กจาไว้ในคอมพิวเตอร์ หากต้องการใช้ก็ เพีย งวาง
Ctrl+V
รู ปที่ 3-9 คัดลอกตาแหน่งไฟล์ภาษาเครื่ อง (HEX file)
8. ในกรณี ที่ตอ้ งการอัพโหลดโค้ดลงชิพของวงจรจริ งที่เชื่อมต่อไว้ให้คลิกที่ปุ่ม Upload ดังรู ป
รู ปที่ 3-10 ปุ่ มอัพโหลดโค้ดลงชิพไมโครคอนโทรลเลอร์

3.2 การติดตั้งไดร์ ฟเวอร์ USB

บอร์ ด Arduino ปั จจุบนั มีหลายรุ่ นซึ่ งแต่ละรุ่ นอาจใช้ชิพสาหรับติ ดต่อสื่ อสารผ่านพอร์ ต USB
แตกต่างกันไป ซึ่ งบางรุ่ นมีไดร์ ฟเวอร์ มาให้พร้ อมในตัวโปรแกรม Arduino IDE แล้วเช่ นบอร์ ดที่ใช้ชิพ
CP210x, FTDI, หรื อบอร์ ดที่ใช้ไมโครคอนโทรลเลอร์ เป็ นตัวสื่ อสารผ่าน USB ดังนั้นการติดตั้งผูใ้ ช้งาน
สามารถเรี ยกใช้ได้เลยโดยไม่ตอ้ งไปหาดาวน์โหลดไดร์ ฟเวอร์ อีก โดยไดร์ ฟเวอร์ จะอยู่ในโฟลเดอร์
C:\arduino-1.8.4\drivers ดังรู ป
รู ปที่ 3-11 โฟลเดอร์ ที่เก็บไดร์ เวอร์ สาหรับชิพ USB บางรุ่ น
ยกเว้นบอร์ดที่ใช้ชิพ CH340,CH341 (บอร์ด Arduino Nano 3.0 เลือกใช้ชิพเบอร์ น้ ีในบางผูผ้ ลิต)

ซึ่งผูใ้ ช้งานจะต้องไปหาดาวน์โหลดไดร์ ฟเวอร์ เพื่อมาติดตั้งเอง การดาวน์โหลดสามารถดาวน์โหลด
ไดร์ฟเวอร์ได้ที่
http://www.winchiphead.com/download/CH341/CH341SER.ZIP
การติดตั้งมีข้ นั ตอนดังนี้
1. แตกไฟล์ zip ไดร์ ฟเวอร์ ที่ดาวน์โหลดจากลิงค์ที่กล่าวมาแล้วข้างต้น
2. เข้าไปในโฟลเดอร์ CH341SER แล้วดับเบิลคลิกที่ไฟล์ setup.exe ดังรู ป
รู ปที่ 3-12 โฟลเดอร์ ที่เก็บไดร์ เวอร์ สาหรับชิพ CH341หลังจากการแตกไฟล์

3. คลิกที่ปุ่ม install เพื่อติดตั้งไดร์ ฟเวอร์ USB ที่ใช้ชิพ CH340, CH341 ดังรู ป
รู ปที่ 3-13 หน้าตาของโปรแกรมสาหรับติดตั้งไดร์ ฟเวอร์ USB ที่ใช้ชิพ CH340, CH341
4. ตรวจสอบการทางานของไดร์ ฟเวอร์ ดว้ ยการเชื่ อมต่อบอร์ ด Arduino เข้ากับคอมพิวเตอร์ ดว้ ย

สาย USB ทาการเปิ ด Device Manager สังเกตพอร์ ตสื่ อสารที่ปรากฏขึ้นดังรู ป
รู ปที่ 3-14 ผลการติดตั้งไดร์ ฟเวอร์ หลังการเชื่อมต่อบอร์ ด Arduino Nano 3.0
3.3 เครื่ องมือจาลองการทางาน

สาหรั บผูท้ ี่ ต้องการทดลองวงจรโดยที่ ยงั ไม่มี วงจรจริ ง การจาลองด้วยโปรแกรมจาลองการ
ทางานของวงจรเป็ นทางเลือกที่เหมาะสม โปรแกรมที่สามารถทดลองวงจรไมโครคอนโทรลเลอร์ ได้ดี
โปรแกรมหนึ่งที่ได้รับความนิยมคือ Proteus และเนื่องจากโปรแกรมจาลองการทางานดังกล่าวจาเป็ นต้อง
ติดตั้งให้เป็ นโปรแกรมตัวเต็มจึงไม่สามารถเสนอขั้นตอนการติดตั้งนี้ ได้ ซึ่ งผูใ้ ช้งานสามารถหาวิธีการ
ติดตั้งได้จากอินเตอร์ เน็ตได้ สาหรับขั้นตอนนี้ เป็ นขั้นตอนเตรี ยมโปรแกรมให้สามารถจาลอง Arduino
ได้เนื่องจากโปรแกรม Proteus หลังติดตั้งเรี ยบร้อยแล้วจะยังไม่มีโมเดลของบอร์ ด Arduino ให้ใช้งานจึง
จาเป็ นต้องดาเนินการให้มีก่อน ซึ่ งโมเดลจาลอง Arduino ผูเ้ ขียน (ครู ประภาส สุ วรรณเพชร) ได้จ ัดสร้าง
โมเดลจาลองไว้ให้ผใู ้ ช้งานทัว่ ไปสามารถนาไปใช้งานได้ ขั้นตอนการดาเนินการมีดงั นี้
1. ดาวน์โหลดโมเดลจาลอง Arduino ที่
http://www.praphas.com/download/arduino/ArduinoONO-RX[Lib].rar
2. ทาการแตกไฟล์ แล้วคัดลอกไฟล์โมเดลจาลองทั้งสองไฟล์ดงั รู ป
รู ปที่ 3-15 คัดลอกไฟล์โมเดลจาลองทั้งสองไฟล์
3. โดยนาไปวางไว้ในโฟลเดอร์ library ของโปรแกรม Proteus
รู ปที่ 3-16 วางไฟล์โมเดลจาลองทั้งสองไฟล์ที่คดั ลองมาในโฟลเดอร์ LIBRARY

หมายเหตุ
*windows 32bit C:\Program Files\Labcenter Electronics\Proteus 8 Professional\LIBRARY
*windows 64bit C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
ในกรณี ที่ลงเวอร์ ชนั่ 8 ตาแหน่งจะอยูใ่ นพิกดั ที่คล้ายกันเพียงแต่เป็ นชื่ อ Proteus 8
การจาลองการทางานด้ วยโปรแกรม Proteus

การทดลองการท างานของวงจรไมโครคอนโทรลเลอร์ Arduino แบบจาลองการทางานด้วย
โปรแกรม Proteus สามารถเรี ยกใช้บอร์ด Arduino ได้ซ่ ึงโมเดล Arduino จะอยูใ่ นเมนู Emulator ดังรู ป
รู ปที่ 3-17 ไมโครคอนโทรลเลอร์ Arduino

ขั้นตอนการจาลองการทางานมีดงั นี้
1. เลือกอุปกรณ์ที่ตอ้ งการใช้งานให้อยูใ่ นช่องรายการ
รู ปที่ 3-18 การเลือกอุปกรณ์เพื่อใช้งาน
2. ทาการต่อวงจรตามใบงานที่ตอ้ งการทดลอง
รู ปที่ 3-19 ต่อวงจรเพื่อทดลอง
3. คัดลอกตาแหน่งไฟล์ภาษาเครื่ องจากโปรแกรม Arduino IDE แล้วคลิกวางตาแหน่งไฟล์

ภาษาเครื่ อง ( Ctrl+V ) ลงในช่อง Program File: โดยการดับเบิลคลิกที่ตวั Arduino
รู ปที่ 3-20 วางตาแหน่งไฟล์ภาษาเครื่ อง (HEX file) ลงในช่อง

4. คลิกปุ่ ม Run เพื่อเริ่ มจาลองการทางาน
รู ปที่ 3-21 เริ่ มจาลองการทางาน

บทที่ 4 ใบงานการทดลอง  55
บทที่ 4
ใบงานการทดลอง
ใบงานที่ 4.1 การทดสอบบอร์ ดเบื้องต้น
ใบงานที่ 4.2 การเขียนโปรแกรมสื่ อสารทางพอร์ตอนุกรม
ใบงานที่ 4.3 การเขียนโปรแกรมใช้งานพอร์ ตทาหน้าที่เอาท์พุทพอร์ ตเบื้องต้น
ใบงานที่ 4.4 การเขียนโปรแกรมรับค่าจากพอร์ ตดิจิทลั
ใบงานที่ 4.5 การเขียนโปรแกรมอ่านค่าจากพอร์ ตแอนาลอกและการใช้ PWM
ใบงานที่ 4.6 การเขียนโปรแกรมรับสวิตช์ทางพอร์ ตแอนาลอก
ใบงานที่ 4.7 การเขียนโปรแกรมวัดอุณหภูมิดว้ ยเทอร์มิสเตอร์ชนิด NTC
ใบงานที่ 4.8 การเขียนโปรแกรมวัดอุณหภูมิและความชื้นด้วยโมดูล DHT22
ใบงานที่ 4.9 การเขียนโปรแกรมใช้งานไอซีวดั อุณหภูมิ DS18B20
ใบงานที่ 4.10 การเขียนโปรแกรมวัดระยะด้วยโมดูลอัลตร้าโซนิค
ใบงานที่ 4.11 การเขียนโปรแกรมควมคุมดีซีมอเตอร์
ใบงานที่ 4.12 การเขียนโปรแกรมควมคุมสเต็ปเปอร์มอเตอร์
ใบงานที่ 4.13 การเขียนโปรแกรมควมคุมเซอร์ โวมอเตอร์
ใบงานที่ 4.14 การเขียนโปรแกรมใช้งานอินเตอร์ รัพท์
ใบงานที่ 4.15 การเขียนโปรแกรมใช้งานหน่วยความจา EEPROM
ใบงานที่ 4.16 การเขียนโปรแกรมใช้งานคียแ์ พด
ใบงานที่ 4.17 การเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ 4 บิต
ใบงานที่ 4.18 การเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ I2C
ใบงานที่ 4.19 การเขียนโปรแกรมแสดงผลด้วยโมดูลตัวเลข MAX7219
ใบงานที่ 4.20 การเขียนโปรแกรมแสดงผลด้วยจอ OLED 128×64
ใบงานที่ 4.21 การเขียนโปรแกรมแสดงผลรู ปภาพด้วยจอ OLED 128×64
ใบงานที่ 4.22 การประยุกต์การแสดงผลที่ LCD 4 bit กับเซนเซอร์ ต่าง ๆ
ใบงานที่ 4.23 การประยุกต์การแสดงผลที่ LCD I2C กับเซนเซอร์ ต่าง ๆ
ใบงานที่ 4.24 การประยุกต์การแสดงผลด้วยโมดูล MAX7219 กับเซนเซอร์ ต่าง ๆ
ใบงานที่ 4.25 การประยุกต์การแสดงผลที่ OLED กับเซนเซอร์ ต่าง ๆ
ใบงานในหน่ วยการเรี ย นนี้ เป็ นใบงานที่ รวบรวมขึ้ นเพื่ อให้ผูเ้ รี ย นสามารถเรี ย นรู ้ การใช้ง าน
ไมโครคอนโทรลเลอร์ ข้ นั พื้นฐาน ตลอดจนมีทกั ษะในการสร้างวงจรเพื่อประยุกต์ใช้งานได้ดว้ ยตนเอง
โดยใบงานมี ท้ ัง หมด 25 ใบงานซึ่ งเป็ นใบงานขั้น พื้ น ฐานเพื่ อ ให้ ผู ้ที่ ย ัง ไม่ มี พ้ื น ฐานการเขี ย น
โปรแกรมควบคุมงานด้วยไมโครคอนโทรลเลอร์ มาก่อนสามารถเรี ยนรู ้ได้ ในแต่ละใบงานมีตวั อย่างการ
เขียนโปรแกรมขั้นพื้นฐานเพื่อให้สามารถเข้าใจได้ง่ายและเป็ นแนวทางที่จะฝึ กเขียนโปรแกรมควบคุม
งานในโจทย์แบบฝึ กหัดได้
ปฏิบตั ิการทดลองวงจรไมโครคอนโทรลเลอร์ และวงจรเชื่ อมต่อได้ดว้ ยตนเอง เขียนโปรแกรม
สัง่ งานวงจรไมโครคอนโทรลเลอร์ Arduino จาลองการทางานด้วยโปรแกรม Proteus
1. เพื่อให้มีทกั ษะในการต่อวงจรไมโครคอนโทรลเลอร์ และวงจรต่อพ่วง
2. เพื่อให้มีทกั ษะในการตรวจสอบวงจรในกรณี ที่วงจรไม่ทางาน
3. เพื่อให้มีทกั ษะในการแก้ไขปั ญหาในกรณี ที่วงจรไม่ทางาน
4. เพื่อให้มีความรู ้เกี่ยวกับการเขียนโปรแกรมภาษาซี สาหรับไมโครคอนโทรลเลอร์
5. เพื่อให้เข้าใจการทางานของวงจรด้วยการจาลองการทางานด้วยโปรแกรม Proteus
6. เพื่อให้สามารถทดลองด้วยวงจรจริ งที่สร้างขึ้นเอง
7. เพื่อให้มีความรับผิดชอบในการจัดทาใบงานให้เสร็ จทันเวลา
1. ต่อวงจรไมโครคอนโทรลเลอร์ และวงจรต่อพ่วงได้
2. ตรวจสอบวงจรในกรณี ที่วงจรไม่ทางานได้
3. แก้ไขปั ญหาในกรณี ที่วงจรไม่ทางานได้
4. เขียนโปรแกรมภาษาซี ควบคุมไมโครคอนโทรลเลอร์ ตามตัวอย่างได้
5. เขียนโปรแกรมภาษาซี ควบคุมไมโครคอนโทรลเลอร์ ในงานที่มอบหมายได้
6. ทดลองวงจรด้วยการจาลองการทางานด้วยโปรแกรม Proteus ได้
7. ทดลองด้วยวงจรจริ งที่สร้างขึ้นเองได้
8. ทาใบงานเสร็ จทันเวลา
ใบงานที่ 4.1 การทดสอบบอร์ดเบื้องต้น  57
ใบงานที่ 4.1
การทดสอบบอร์ ดเบื้องต้ น
1. จุดประสงค์ ทวั่ ไป
เพื่อให้สามารถทดสอบบอร์ ดเบื้องต้นได้
2. จุดประสงค์ เชิงพฤติกรรม
1. บอกวิธีการทดสอบบอร์ ดเบื้องต้นได้
2. บอกขั้นตอนการต่อวงจรเพื่อทดลองบนบอร์ ดทดลองได้
3. ทดสอบการทางานของบอร์ด Arduino ได้
4. ปฏิบตั ิงานตามใบงานเสร็ จทันเวลาที่กาหนด
3. เครื่ องมือและอุปกรณ์
1. บอร์ดทดลอง Breadboard 830 Point 1 แผ่น
2. อุปกรณ์อิเล็กทรอนิกส์ ประกอบด้วย
2.1 ตัวต้านทาน 220 ohm 1 ตัว
2.2 LED 3mm 1 ตัว
3. บอร์ด Arduino Nano 3.0 1 ตัว
4. สายเชื่อมต่อ USB (Mini USB) 1 เส้น
5. คอมพิวเตอร์ 1 เครื่ อง
4. ลาดับขั้นการปฏิบัติงาน
1. ศึกษาจุดประสงค์ทวั่ ไปจุดประสงค์เชิงพฤติกรรมและทฤษฎีพ้นื ฐานที่เกี่ยวข้อง
2. ดาเนินการต่อวงจรลงบอร์ ดทดลองตามวงจรที่กาหนด
3. เขียนโปรแกรมควบคุมและทดสอบการทางานของวงจร
4. สรุ ปผลการปฏิบตั ิงาน
5. ทฤษฎีพืน้ ฐาน
ใบงานนี้ เป็ นใบงานสาหรับเตรี ยมเครื่ องมือและทดสอบการทางานเบื้องต้นของบอร์ ด Arduino
ว่าใช้งานได้ปกติหรื อไม่ โดยการเขียนโค้ดโปรแกรมให้ LED ที่อยูบ่ นบอร์ ด Arduino ซึ่ งต่ออยูท่ ี่ขา D13
ติดและดับสลับกัน ในกรณี ที่ตอ้ งการต่อวงจร LED เพิ่มภายนอกจะต้องต่อวงจร LED ให้สามารถติดได้
เมื่อรับลอจิก 1 ดังนั้นจะต้องต่อ LED อนุกรมกับตัวต้านทานลงกราวด์ดงั รู ป
ARDUINO
R1 LED1
220
D13
GND
รู ปที่ 4.1-1 วงจร Arduino ที่เชื่อมต่อกับ LED จานวน 1 ตัว
ค่าความต้านทานที่ใช้งานสามารถคานวณหาได้ดว้ ยกฎของโอห์ม โดยมีขอ้ กาหนดที่ค่าแรงดัน

ตกคร่ อมและกระแสของ LED เป็ น 2V และ 15mA ตามลาดับ ดังนั้นค่าความต้านทานจึงมีค่าเท่ากับ
VCC  VLED 52
R = VR  = = 200
I I 15 103
6. ฟังก์ชั่นทีใ่ ช้ งานในใบงาน
รู ปแบบของฟังก์ชนั่ ที่ใช้งานในใบงานนี้มีดงั นี้
1. ฟังก์ชั่นกาหนดโหมดการทางานให้ กบั ขาพอร์ ต สามารถกาหนดได้ท้ งั ขาดิจิตอลโดยใส่ เพียง
ตัวเลขของขา (0, 1, 2,…13) และขาแอนาลอกที่ตอ้ งการให้ทางานในโหมดดิจิตอลได้จะต้อง
ใส่ A นาหน้า ซึ่ งใช้ได้เฉพาะ A0, A1,…A5 ส่ วนขา A6 และ A7 (ที่มีในบอร์ ด Arduino รุ่ น
Mini และ Nano) ไม่สามารถใช้งานในโหมดดิจิตอลได้ รู ปแบบของฟังก์ชนั่ เป็ นดังนี้
pinMode(pin, mode);
pin: หมายเลขขาที่ตอ้ งการเซตโหมด
mode: INPUT, OUTPUT, INPUT_PULLUP
ตัวอย่างเช่ น
pinMode(13,OUTPUT); หมายถึง กาหนดให้ขา D13 ทางานเป็ นเอาต์พุตพอร์ต
pinMode(12, INPUT_PULLUP); หมายถึ ง กาหนดให้ขา D12 ทางานเป็ นอินพุตพอร์ ต

ที่ใช้ตวั ต้านทานพูลอัพภายในชิพ
2. ฟั งก์ ชั่นส่ งค่ าลอจิกดิจิตอลไปยังขาพอร์ ต โดยค่า HIGH เป็ นการส่ งลอจิก 1 และค่า LOW
เป็ นการส่ งลอจิก 0 ออกไปยังขาพอร์ ต ฟั งก์ชนั่ นี้ จะทางานได้ตอ้ งมีการใช้ฟังก์ชนั่ pinMode
ก่อน
digitalWrite(pin, value);
pin: หมายเลขขาที่ตอ้ งการเขียนลอจิกออกพอร์ต
value: HIGH or LOW
digitalWrite(13,HIGH); หมายถึง กาหนดให้ส่งลอจิก 1 ไปที่ขา D13
digitalWrite(13,LOW); หมายถึง กาหนดให้ส่งลอจิก 0 ไปที่ขา D13
3. ฟั ง ก์ ชั่ น หน่ ว งเวลาหรื อ ฟั ง ก์ ชั่ น หยุ ด ค้ า ง การใช้ง านสามารถก าหนดตัวเลขของเวลาที่

ต้องการหยุดค้างโดยตัวเลขที่ใส่ เป็ นตัวเลขของเวลาหน่วยเป็ นมิลลิวินาที ตัวเลขของเวลาที่
ใส่ ได้สูงสุ ดคือ 4,294,967,295 ซึ่งเป็ นขนาดของตัวแปร unsigned long
delay(ms);
ms: ตัวเลขที่หยุดค้างของเวลาหน่วยมิลลิวนิ าที (unsigned long)
delay(1000) ; หมายถึง หยุดค้าง (หน่วงเวลา) ไว้เป็ นเวลา 1000 มิลลิวนิ าที (1 วินาที)
7. วงจรทีใ่ ช้ ทดลอง
วงจรเพื่อใช้ทดลองในใบงานสามารถทาได้ 3 แนวทางคือ
1. วงจรไมโครคอนโทรลเลอร์ Arduino ที่สร้างเองจากไมโครคอนโทรลเลอร์ AVR
2. วงจรไมโครคอนโทรลเลอร์ Arduino ที่ใช้บอร์ ดโมดูล Arduino สาเร็ จรู ป
3. ทดลองด้วยการจาลองการทางานด้วยโปรแกรม Proteus
กรณี ที่ใช้วงจรที่สร้างขึ้นเองจากไอซี ไมโครคอนโทรลเลอร์ AVR ที่ลงบูตโหลดเดอร์เป็ น Arduino

เรี ยบร้อยแล้ว ต่อวงจรดังรู ป
VCC
D1 CPU circuit Peripheral circuit

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
R2,R3 R4
USB to UART (TTL Level) 1k 220
DTR 3 D13 19
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND LED1
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22
รู ปที่ 4.1-2 วงจรที่ใช้ไอซี AVR ในการทดลอง
กรณี ที่ใช้ Arduino ในการทดลอง ต่อวงจรดังรู ป

ARDUINO
R1 LED1
220
D13
GND
รู ปที่ 4.1-3 วงจรที่ใช้บอร์ด Arduino ในการทดลอง
การต่อวงจรไมโครคอนโทรลเลอร์ Arduino ที่ใช้บอร์ ดโมดูล Arduino สาเร็ จรู ปลงบอร์ดทดลอง

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1
รู ปที่ 4.1-4 การต่อลงบอร์ ดทดลอง

การต่อวงจรเพื่อทดลองด้วยการจาลองการทางานด้วยโปรแกรม Proteus
รู ปที่ 4.1-5 การต่อวงจรทดลองในโปรแกรมจาลองการทางาน
8. การเขียนโค้ ดโปรแกรมควบคุม
ใบงานนี้ เป็ นใบงานทดสอบการทางานของบอร์ ด Arduino ว่าทางานได้สมบูรณ์หรื อไม่สามารถ

รับการอัพโหลดจากโปรแกรม Arduino IDE ได้หรื อไม่ การทดสอบเป็ นการเขียนโค้ดโปรแกรมให้ LED
ที่ อยู่บนบอร์ ดติ ดดับสลับกันในเวลาที่ กาหนดซึ่ ง LED ดังกล่ าวต่ออยู่กบั ขาดิ จิตอลขา D13 การเขีย น
โปรแกรมมีข้ นั ตอนดังนี้
ลาดับงาน การเขียนโปรแกรมจากโจทย์ที่กาหนดข้างต้นเขียนลาดับงานได้ดงั นี้
1. กาหนดชื่อตัว LED กับขาพอร์ ตที่ตอ้ งใช้งาน 5. ส่ งค่า LOW ไปยังขาพอร์ตเพื่อให้ LED ดับ
2. กาหนดโหมดขาที่เชื่ อมต่อ LED 6. หน่วงเวลา
3. ส่ งค่า HIGH ไปยังขาพอร์ ตเพื่อให้ LED ติด 7. วนกลับไปทาลาดับที่ 3 ซ้ า
4. หน่วงเวลา
แปลงลาดับงานเป็ นผังงาน จากลาดับงานสามารถเขียนเป็ นผังงานได้ดงั นี้
START
Set pin mode
Out to pin
delay
Out to pin
delay
แปลงผังงานเป็ นโปรแกรม จากผังงานสามารถเขียนเป็ นโค้ดโปรแกรมควบคุม Arduino

1 #define LED 13
2 void setup()
3 {
4 pinMode(LED, OUTPUT);
5 }
6 void loop()
7 {
8 digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level)
9 delay(1000); // wait for a second
10 digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW
11 delay(1000); // wait for a second
12 }
- บรรทัดที่ 1 ประกาศชื่อ LED แทนตัวเลข 13
- บรรทัดที่ 4 กาหนดโหมดของขาพอร์ ตที่เชื่อมต่อ LED ให้ทางานเป็ นเอาท์พุทพอร์ต
- บรรทัดที่ 8 ส่ งค่าลอจิก 1 ออกทางขาพอร์ ตที่ต่อ LED
- บรรทัดที่ 9 หน่วงเวลา 1 วินาที (1000 mS)
- บรรทัดที่ 10 ส่ งค่าลอจิก 0 ออกทางขาพอร์ ตที่ต่อ LED
- บรรทัดที่ 11 หน่วงเวลา 1 วินาที (1000 mS)
ทดลองการทางาน
1. จาลองการทางานด้วยโปรแกรม Proteus
2. ทดลองด้วยวงจรจริ ง
3. ทดลองแก้โปรแกรมจาก delay(1000); เป็ นตัวเลขอื่น แล้วสังเกตผล
9. สรุปผลการปฏิบัติงาน
ใบงานที่ 4.2 การเขียนโปรแกรมสื่ อสารทางพอร์ตอนุกรม  63
การเขียนโปรแกรมสื่ อสารทางพอร์ ตอนุกรม
เพื่อให้สามารถเขียนโปรแกรมสื่ อสารทางพอร์ตอนุกรมได้
1. บอกวิธีเขียนโปรแกรมสื่ อสารทางพอร์ตอนุกรมได้
การสื่ อ สารแบบอนุ ก รมเป็ นการส่ ง ข้อ มู ล ไปที ล่ ะ บิ ต โดยใช้ เ ทคนิ ค การเลื่ อ นข้อ มู ล บน
สายสัญญาณเส้นเดียว การส่ งข้อมูลแบบอนุกรมนี้จะไม่มีการส่ งสัญญาณนาฬิกาจากตัวส่ งไปยังตัวรับ แต่
จะอาศัยวิธีต้ งั ค่าความเร็ วในการรับส่ งสัญญาณให้เท่ากัน ซึ่ งเรี ยกว่า “อัตราบอด” โดยเรี ยกทับศัพท์ว่า
“บอดเรต” (baud rate) ในการส่ งข้อมูลจะส่ งบิตเริ่ มต้น (Start bit) เพื่อส่ งสัญญาณบอกให้ภาครับรับรู ้ ว่า
จะมีการส่ งข้อมูลไปแล้วในเวลาอันใกล้น้ ี และเมื่อส่ งข้อมูลเสร็ จจะส่ งบิตหยุด (Stop bit) เป็ นบิตปิ ดท้าย
ขบวนข้อมูลในไบต์น้ นั ๆ ดังรู ป
รู ปที่ 4.2-1 รู ปแบบของข้อมูลที่สื่อสารแบบอนุกรม
รู ปแบบของ ข้อมูลจากที่ส่งผ่าน Serial จะมีการเพิม่ Start bit และ Stop bit เข้าไปเพิม่ จากข้อมูลเดิม
1. บิตเริ่ มต้น (Start bit) จะมีขนาด 1 บิต จะเป็ นลอจิก LOW
2. บิตข้อมูล (Data bit) 8 บิต ข้อมูลที่จะส่ ง
3. บิตภาวะคู่หรื อคี่ (Parity bit) มีขนาด 1 บิต ใช้ตรวจสอบข้อมูลความถูกต้องของข้อมูล
4. บิตหยุด (Stop bit) เป็ นการระบุถึงขอบเขตของการสิ้ นสุ ดข้อมูล จะเป็ นลอจิก HIGH
6. ฟังก์ชั่น Arduino ทีใ่ ช้ ในใบงาน

1. ฟังก์ ชั่นกาหนดโหมดการทางานให้ กับขาพอร์ ต สามารถกาหนดได้ท้ งั ขาดิจิทลั โดยใส่ เพียง
ตัวเลขของขา (0, 1, 2,…13) และขาแอนาลอกที่ตอ้ งการให้ทางานในโหมดดิจิทลั แต่การใส่
ขาต้องใส่ A นาหน้าซึ่งใช้ได้เฉพาะ A0, A1,…A5 ส่ วนขา A6 และ A7 ไม่สามารถใช้งานใน
โหมดดิจิทลั ได้ รู ปแบบของฟังก์ชนั่ เป็ นดังนี้
pinMode(pin, mode);
2. ฟังก์ชั่นส่ งค่ าลอจิกดิจิทลั ไปยังขาพอร์ ต ค่า HIGH เป็ นการส่ งลอจิก 1 และค่า LOW เป็ นการ
ส่ งลอจิก 0 ออกไปยังขาพอร์ ต ซึ่ งฟังก์ชนั่ นี้จะทางานได้ตอ้ งมีการใช้ฟังก์ชนั่ pinMode ก่อน
value: HIGH or LOW

delay(ms);
4. ฟั งก์ ชั่นกาหนดความเร็ วในการสื่ อสารทางพอร์ ตอนุ กรม เพื่อให้สามารถสื่ อสารระหว่าง

อุ ปกรณ์ ท้ งั สองฝั่ งได้จะต้องกาหนดอัตราเร็ วในการสื่ อสารหรื อเรี ยกว่าอัตราบอด (Baud
rate) ซึ่ งค่าความเร็ วนี้ มีหน่ วยเป็ นบิ ตต่ อวินาที (bps: bit per second) ค่าความเร็ วนี้ ไ ด้แก่
300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, หรื อ 115200
Serial.begin(speed);
speed: ตัวเลขของอัตราเร็ วในการสื่ อสารผ่านพอร์ ตอนุกรม
ตัวอย่าง
Serial.begin(9600); หมายถึ ง กาหนดอัตราเร็ วของการสื่ อสารทางพอร์ ตอนุ ก รม
เป็ น 9600 บิตต่อ 1 วินาที
5. ฟั งก์ ชั่นตรวจสอบว่ ามีข้อมู ลเข้ ามายังพอร์ ตอนุ กรมหรื อไม่ โดยค่าที่ ได้จากฟั งก์ชนั่ เป็ น
จานวนของข้อมูลที่เข้ามา แต่ถา้ หากไม่มีขอ้ มูลเข้าค่าที่ได้จากฟังก์ชนั่ จะมีค่าเป็ นศูนย์
Serial.available();
if (Serial. available()>0) หมายถึง ตรวจสอบว่ามีขอ้ มูลเข้ามายังพอร์ ตอนุ กรมหรื อไม่
หากมี (ค่าจะมากกว่า 0) ให้ทางานในกรอบงานของ if แต่ถา้ ไม่มีขอ้ มูลเข้ามาให้ขา้ ม
เงื่อนไข if นี้ไป
6. ฟังก์ ชั่นอ่ านข้ อมูลทีเ่ ข้ ามายังพอร์ ตอนุกรม

Serial. read();
x = Serial.read(); หมายถึงอ่านค่าจากพอร์ ตอนุกรมมาเก็บลงในตัวแปร x
7. ฟังก์ ชั่นล้ างข้ อมูลในบัฟเฟอร์ ของพอร์ ตอนุกรมฝั่งด้านรับให้วา่ ง

Serial.flush()
Serial.flush(); หมายถึง ล้างข้อมูลบัฟเฟอร์ ของพอร์ ตอนุกรมฝั่งด้านรับ
8. ฟังก์ชั่นส่ งข้ อมูลออกพอร์ ต เป็ นฟังก์ชนั่ ที่ใช้ในการส่ งข้อมูลออกทางพอร์ ตอนุกรมหรื ออาจ

เรี ยกว่าฟั งก์ชนั่ พิมพ์ขอ้ มูลออกทางพอร์ ตเพื่อแสดงผลที่จอคอมพิวเตอร์ ที่เชื่ อมต่อกับวงจร
Arduino ฟังก์ชนั่ นี้เมื่อพิมพ์เสร็ จตัวเคอร์ เซอร์ จะรออยูท่ ี่ทา้ ยสิ่ งที่พิมพ์น้ นั ๆ
Serial.print(val)
Serial.print(val, format)
Serial.print(78) ผลที่ได้คือ "78" Serial.print(78, OCT) ผลที่ได้คือ "116"
Serial.print(1.23456) ผลที่ได้คือ "1.23" Serial.print(78, DEC) ผลที่ได้คือ "78"
Serial.print('N') ผลที่ได้คือ "N" Serial.print(78, HEX) ผลที่ได้คือ "4E"
Serial.print("Hello") ผลที่ได้คือ "Hello" Serial.print(1.23456, 0) ผลที่ได้คือ "1"
Serial.print(78, BIN) ผลที่ได้คือ "1001110" Serial.print(1.23456, 2) ผลที่ได้คือ "1.23"
Serial.print(1.23456, 4) ผลที่ได้คือ "1.2346"
9. ฟั งก์ ชั่นส่ งข้ อมู ลออกพอร์ ต คล้ายกับฟั งก์ชั่น Serial.print ต่างกันตรงที่ เมื่ อพิ มพ์เสร็ จ ตัว
เคอร์ เซอร์ จะขึ้ นมารอยังบรรทัดใหม่ ดังนั้นเมื่ อสั่งพิมพ์ครั้ งถัดไปข้อมูลที่ ปรากฏจะอยู่ที่
บรรทัดใหม่ แทนที่จะต่อท้ายเหมือนกับฟังก์ชนั่ Serial.print
Serial.println(val)
Serial.println(val, format)

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
R2,R3 R4
DTR 3 D13 19
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
LED1
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
R1 LED1
220
D13
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การต่อวงจรเพื่อทดลองด้วยการจาลองการทางานด้วยโปรแกรม Proteus อุปกรณ์เชื่ อมต่อเพื่อสื่ อสารทาง
พอร์ตอนุกรมใช้ VIRTUAL TERMINAL ซึ่ งอยูใ่ นกลุ่ม INSTRUMENTS
การทดลองที่ 1 รับข้อมู ลจากพอร์ ตอนุ กรมซึ่ งส่ งจากคอมพิ วเตอร์ มายังบอร์ ด Arduino แล้วส่ งค่านั้น
กลับไปยังคอมพิวเตอร์ อีกครั้งเพื่อแสดงผลสิ่ งที่ส่งมา
1 int incomingByte = 0;
START 2 void setup()
3
{
4
Serial.begin(9600);
กาหนดค่าเริ ่มต้ นต่ า ง 5
}
6
7 void loop()
ไม่ใช่ 8 {
มีข้อมูลเข้า ? 9 if (Serial.available() > 0)
10 {
ใช่ 11 incomingByte = Serial.read();
12
Serial.print("I received: ");
เก็บ ค่าเข้ า ตัวแปร 13
14 Serial.println(incomingByte, DEC);
}
}
ส่ งค่ า ตัวแปรไปแสดงผล
- บรรทัดที่ 1 ประกาศตัวแปรสาหรับเก็บค่าข้อมูลที่รับเข้ามาทางพอร์ ตอนุกรม
- บรรทัดที่ 4 กาหนดอัตราเร็ วของการสื่ อสารของพอร์ ตอนุกรม (กาหนด Baud rate)
- บรรทัดที่ 8 ตรวจสอบว่ามีขอ้ มูลเข้ามาหรื อไม่ หากมีขอ้ มูลเข้ามาทางพอร์ ตอนุ กรมค่าที่ส่งออก
มาจากฟังก์ชนั่ Serial.available จะมากกว่าศูนย์
- บรรทัดที่ 10 อ่านค่าจากพอร์ ตอนุกรมนาเข้ามาเก็บลงในตัวแปรที่เตรี ยมไว้
- บรรทัดที่ 11 แสดงข้อความ “I received:” ที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
- บรรทัดที่ 12 แสดงค่าในตัวแปร incomingByte ที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
3. ทดลองแก้โปรแกรมให้แสดงผลตัวแปรรู ปแบบอื่น ๆ แล้วสังเกตผล
การทดลองที่ 2 รับข้อมู ลจากพอร์ ตอนุ กรมซึ่ งส่ งมาจากคอมพิวเตอร์ มายังบอร์ ด Arduino แล้วทาการ
ตรวจสอบว่าข้อมูลดังกล่าวใช่ ตวั อักษร a หรื อไม่ หากข้อมูลเป็ นตัวอักษร a ให้ LED ที่ต่ออยู่ที่ขา D13
สว่างแต่ถา้ ข้อมูลที่เข้ามาไม่ใช่ตวั อักษร a ให้ LED นั้นดับ
1 #define LED 13
START 2 int incomingByte = 0;
3 void setup()
4 {
กาหนดค่าเริ ่มต้ นต่ า ง 5
Serial.begin(9600);
6
ไม่ใช่ 8 }
มีข้อมูลเข้า ? 9 void loop(){
10 if (Serial.available() > 0) {
ใช่ 11
incomingByte = Serial.read();
12
ใช่ ไม่ใช่ if(incomingByte =='a')
ใช่ a ? 13
14 {
15 digitalWrite(LED,HIGH);
LED ติด LED ดับ 16
17
}
else
18 {
20 }
}
}
- บรรทัดที่ 1 กาหนดชื่อ LED ให้แทน 13 (ในวงจรจริ ง LED ต่ออยูก่ บั ขา D13)
- บรรทัดที่ 2 ประกาศตัวแปรสาหรับเก็บค่าข้อมูลที่รับเข้ามาทางพอร์ ตอนุกรม
- บรรทัดที่ 6 กาหนดโหมดให้กบั ขาพอร์ ตทางานเป็ นเอาต์พุทพอร์ ต

- บรรทัดที่ 9 ตรวจสอบว่ามีขอ้ มูลเข้ามาหรื อไม่ หากมีขอ้ มูลเข้ามาทางพอร์ ตอนุ กรมค่าที่ส่งออก
จากฟังก์ชนั่ Serial.available จะมากกว่าศูนย์
- บรรทัดที่ 10 อ่านค่าจากพอร์ ตอนุกรมนาเข้ามาเก็บลงในตัวแปรที่เตรี ยมไว้
- บรรทัดที่ 11 ตรวจสอบค่าในตัวแปร (ข้อมูลที่รับเข้ามา) มีค่าเท่ากับตัวอักษร a หรื อไม่
- บรรทัดที่ 13 ถ้าค่าในตัวแปรมีค่าเท่ากับตัวอักษร a ให้ส่งลอจิก 1 ออกพอร์ต
- บรรทัดที่ 17 ถ้าค่าในตัวแปรมีค่าไม่เท่ากับตัวอักษร a ให้ส่งลอจิก 0 ออกพอร์ต
3. ทดลองแก้ไขโปรแกรมให้สามารถรับค่าจากตัวอักษรอื่น ๆ ได้
10. งานทีม่ อบหมาย

เขียนโปรแกรมรับข้อมูลจากคอมพิวเตอร์ โดยให้ขอ้ มูล ที่รับเข้ามานั้นสามารถควบคุมการติดดับ
ของ LED ที่ต่ออยูก่ บั Arduino ทั้งหมดซึ่ งวงจรเชื่อมต่อเป็ นดังรู ป
ARDUINO
R1-R4 LED1-LED4
220
D2
D3
D4
D5
GND
รู ปที่ 4.1-6 วงจรทดลองสาหรับงานที่มอบหมาย

ใบงานที่ 4.3 การเขียนโปรแกรมใช้งานพอร์ตทาหน้าที่เอาท์พทุ พอร์ตเบื้องต้น  71
การเขียนโปรแกรมใช้ งานพอร์ ตทาหน้ าทีเ่ อาท์ พทุ พอร์ ตเบื้องต้ น
เพื่อให้สามารถเขียนโปรแกรมใช้งานพอร์ ตทาหน้าที่เอาท์พุทพอร์ ตเบื้องต้นได้
1. บอกวิธีเขียนโปรแกรมใช้งานพอร์ ตทาหน้าที่เอาท์พุทพอร์ ตเบื้องต้นได้
5. สายเชื่อมต่อวงจร 1 ชุด
1. ศึกษาจุดประสงค์ทวั่ ไป จุดประสงค์เชิงพฤติกรรมและทฤษฎีพ้นื ฐานที่เกี่ยวข้อง
บอร์ ดArduino รุ่ นที่ใช้ไอซี ไมโครคอนโทรลเลอร์ ATMEGA328, ATMEGA168, ATMEGA8
จะมีพอร์ ตดิจิทลั ให้สามารถเชื่อมต่อใช้งานได้ 14 ขาด้วยกันโดยเริ่ มจากขา D0, D1,…D13 แต่ในขณะใช้
งานที่ มี ก ารติ ด ต่ อ สื่ อ สารกับ คอมพิ ว เตอร์ ผ่ า นทางพอร์ ต อนุ ก รม (สาย USB ที่ ก าลัง เชื่ อ มต่ อ กับ
คอมพิวเตอร์ ) ขา D0 และ D1 จะถูกใช้งานรับส่ งข้อมูลอยู่ ดังนั้นจึงห้ามใช้ในขณะที่ใช้งานพอร์ ตอนุกรม
รู ปที่ 4.3-1 ขาพอร์ตใช้งานของไอซี Arduino เบอร์ ATMEGA328
6. ฟังก์ชั่น Arduino ทีใ่ ช้ งานในใบงาน

pinMode(pin, mode)
ส่ งลอจิก 0 ออกไปยังขาพอร์ ต ซึ่ งฟั งก์ชนั่ นี้ จะทางานได้จะต้องมีการใช้ฟังก์ชนั่ pinMode
ก่อน
digitalWrite(pin, value)
value: HIGH or LOW

delay(ms)
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
R4-R7 LED1-LED4
220
4
D2
R2,R3 5
USB to UART (TTL Level) 1k D3
DTR 3
RXD D1(TXD) 6
2 D4
TXD D0(RXD)
+5V
GND 11
3V3 D5
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
R1-R4 LED1-LED4
220
D2
D3
D4
D5
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1
การทดลองที่ 1 เขียนโปรแกรมไฟวิง่ LED 4 ตัวติดดับเรี ยงกันไปโดยให้ติดครั้งละ 1 ตัวและที่เหลือดับ
ผังงาน จากโจทย์สามารถเขียนเป็ นผังงานได้ดงั นี้
START A
B
กาหนดค่าเริ ่มต้ นต่ า ง LED 3
LED 1
LED 4
LED 2
A

1 #define LED1 2
2 #define LED2 3
3 #define LED3 4
4 #define LED4 5
5 void setup()
6 {
12 }
13 void loop()
14 {
19 delay(200);
24 delay(200);
29 delay(200);
34 delay(200);
35 }
- บรรทัดที่ 1-4 กาหนดชื่อ LED1, 2, 3, 4 ให้แทน 2, 3, 4, 5 (เป็ นขาที่ LED ต่ออยูก่ บั Arduino)
- บรรทัดที่ 8-11 กาหนดโหมดให้กบั ขาพอร์ ตทางานเป็ นเอาต์พุทพอร์ ต
- บรรทัดที่ 15 ส่ งลอจิก 1 ออกพอร์ ตที่ใช้ชื่อว่า LED1
- บรรทัดที่ 19 หน่วงเวลา 200 mS (1/5 วินาที)
3. ทดลองแก้โปรแกรมให้ LED ติดในรู ปแบบอื่น ๆ แล้วสังเกตผล
การทดลองที่ 2 เขียนโปรแกรมไฟวิ่ง LED 4 ตัวติดดับเรี ยงกันไปโดยให้ติดครั้งละ 1 ตัวและที่เหลือดับ

เช่นเดียวกับการทดลองที่หนึ่ง แต่ใช้วธิ ี การเขียนฟังก์ชนั่ รองชนิดรับค่าแต่ไม่ส่งคืนค่าขึ้นใช้งานเอง
START A
B
กาหนดค่าเริ ่มต้ นต่ า ง LED 3
LED 1
LED 4
LED 2

1 char LED_pin[] = {2,3,4,5};
3 void setup()
4 {
7 {
8 pinMode(LED_pin[i],OUTPUT);
9 }
10 }
11 void loop()
12 {
13 send2port(0B1000);
14 delay(200);
16 delay(200);
18 delay(200);
20 delay(200);
21 }
23 {
28 }
- บรรทัดที่ 1 ประกาศตัวแปรแบบอาร์ เรย์ชื่อ LED_pin และกาหนดค่าเป็ น 2, 3, 4, 5 (เป็ นขาที่
LED ต่ออยูก่ บั Arduino)
- บรรทัดที่ 2 ประกาศรู ปแบบ (Prototype) ของฟั งก์ชนั่ รอง ซึ่ งเป็ นฟั งก์ชนั่ ให้ทาหน้าที่รับค่าที่ส่ง
มาจากฟังก์ชนั่ หลักแล้วคานวณเพื่อส่ งลอจิกออกพอร์ ต
- บรรทัดที่ 6-9 กาหนดโหมดให้กบั ขาพอร์ ตทางานเป็ นเอาต์พุทพอร์ ต โดยใช้คาสั่ง for ในการวน
ทาซ้ า
- บรรทัดที่ 14 หน่วงเวลา 200 mS (1/5 วินาที)
- บรรทัดที่ 22-28 ฟั งก์ชั่นรองที่ รับค่าเข้ามาจากฟั งก์ชั่นหลักผ่านตัวแปร data แล้วนาค่าเข้ามา
ตรวจสอบว่าควรจะต้องส่ งลอจิก 1 หรื อลอจิก 0 ออกทางพอร์ตใด

1. เขียนโปรแกรมไฟวิง่ โดยให้มีรูปแบบของไฟวิง่ ไม่นอ้ ยกว่า 4 รู ปแบบแสดงผลเรี ยงกันไป
โดยใช้วงจรดังรู ป
ARDUINO
R1-R4 LED1-LED4
220
D2
D3
D4
D5
GND

2. เขียนโปรแกรมไฟวิง่ ใช้วงจร Arduino ที่ต่อ LED ทั้งหมดจานวน 8 ตัว โดยให้มีรูปแบบของ

ไฟวิง่ ไม่นอ้ ยกว่า 4 รู ปแบบแสดงผลเรี ยงกันไปในแต่ละรู ปแบบโดยใช้วงจรดังรู ป
ARDUINO
R1-R8 LED1-LED8
220
D2
D3
D4
D5
D6
D7
D8
D9
GND

ใบงานที่ 4.4 การเขียนโปรแกรมรับค่าจากพอร์ตดิจิทลั  79
การเขียนโปรแกรมรับค่ าจากพอร์ ตแบบดิจิทลั
เพื่อให้สามารถเขียนโปรแกรมรับค่าจากพอร์ ตแบบดิจิทลั ได้
1. บอกวิธีเขียนโปรแกรมรับค่าจากพอร์ ตแบบดิจิทลั ได้
2.2 Tack Switch 4 ตัว
4. สายเชื่อมต่อ USB (mini USB) 1 เส้น
บอร์ ด Arduino รุ่ นที่ใช้ไอซี ไมโครคอนโทรลเลอร์ ATMEGA328, ATMEGA168, ATMEGA8
มีพอร์ ตดิ จิทลั ให้สามารถเชื่ อมต่ อใช้งานได้ 14 ขาด้วยกันโดยเริ่ มจากขา D0, D1, …D13 (ขา D0, D1
สงวนไว้ดงั ที่ได้กล่าวมาแล้วในใบงานที่ 4.3) และมีพอร์ตแอนาลอกอีก 6 ขาคือ A0, A1, …A5 ที่สามารถ
นามาใช้งานในโหมดดิจิทลั ได้ ส่ วน A6, A7 ที่มีอยูใ่ นบอร์ ด Arduino รุ่ น Mini และ Nano จะใช้งานได้
เฉพาะการรับสัญญาณเข้าที่เป็ นแอนาลอกเท่านั้น
โหมดการทางานของพอร์ ตที่ให้ทางานแบบดิ จิทลั สามารถสั่งให้ทางานได้ 2 โหมดคือโหมด
เอาท์พุทและโหมดอินพุท ไมโครคอนโทรลเลอร์ ที่ใช้ใน Arduino ส่ วนใหญ่เป็ นตระกูล AVR มีขอ้ โดด
เด่นอีกหนึ่ งประการคือ มีตวั ต้านทานพูลอัพที่มีค่า 20k อยูภ่ ายในซึ่ งผูใ้ ช้งานสามารถที่จะเลือกใช้หรื อไม่
ใช้ก็ได้
เนื่ องจากไมโครคอนโทรลเลอร์ AVR ที่นามาทาเป็ น Arduino สามารถขับกระแสออกจากขา
พอร์ตในโหมดดิจิทลั ได้มากพอสมควรที่จะขับ LED ให้ติดสว่างได้ ดังนั้นการใช้งานเพื่อที่จะขับโหลดที่
เป็ น LED จึงสามารถต่อโดยตรงได้โดยไม่ตอ้ งใช้ไอซี ช่วยขับกระแส ด้วยสาเหตุน้ ี หากนามาขาพอร์ ตมา
ใช้งานเป็ นอินพุทพอร์ ตจึงต้องเปลี่ยนโหมดไม่ให้ไอซี จ่ายกระแสออกมา ในทางปฏิบตั ิเพื่อป้ องกันการ
ผิดพลาดจากการต่อใช้งานหรื อจากการเลื อกโหมดเมื่อนาขาพอร์ ตไปต่อกับสวิตช์ ผูอ้ อกแบบวงจรควร
ใช้ตวั ต้านทานค่าประมาณ 200 ohm อนุกรมกับสวิตช์เพื่อป้ องกันพอร์ ตเสี ยหาย
1. ฟังก์ ชั่นกาหนดโหมดการทางานให้ กับขาพอร์ ต โดยสามารถกาหนดได้ท้ งั ขาดิจิทลั โดยใส่
เพียงตัวเลขของขา (0, 1, 2,…13) และขาแอนาลอกที่ตอ้ งการให้ทางานในโหมดดิจิทลั แต่
การใส่ ขาต้องใส่ A นาหน้าซึ่งใช้ได้เฉพาะ A0, A1,…A5 ส่ วนขา A6 และ A7 ไม่สามารถใช้
งานในโหมดดิจิทลั ได้ รู ปแบบของฟังก์ชนั่ เป็ นดังนี้
pinMode(pin, mode);
ส่ งลอจิก 0 ออกไปยังขาพอร์ ต ฟังก์ชนั่ นี้จะทางานได้ตอ้ งมีการใช้ฟังก์ชนั่ pinMode ก่อน
3. ฟังก์ชั่นอ่านค่ าลอจิกดิจิทลั ที่ขาพอร์ ต เป็ นการอ่านค่าเข้ามาซึ่ งอาจนามาเก็บไว้ในตัวแปรไว้

ตรวจสอบลอจิกทีหลังหรื อจะตรวจสอบลอจิกแบบทันทีก็ได้ ฟั งก์ชนั่ นี้ จะทางานได้ตอ้ งมี
การใช้ฟังก์ชนั่ pinMode ก่อน
digitalRead(pin);
pin: หมายเลขขาพอร์ ตที่ตอ้ งการอ่านลอจิก
value=digitalRead(10); หมายถึง อ่านค่าลอจิกที่ขา D10 มาเก็บไว้ในตัวแปร value
if(digitalRead(10)= =LOW) หมายถึง ตรวจสอบขา D10 ว่าเป็ นลอจิก 0 หรื อไม่

ต้องการหยุดค้าง ตัวเลขที่ใส่ เป็ นตัวเลขของเวลาหน่วยเป็ นมิลลิ วินาที ตัวเลขของเวลาที่ใส่
ได้สูงสุ ดคือ 4,294,967,295 ซึ่งเป็ นขนาดของตัวแปร unsigned long
delay(ms);
5. ฟังก์ ชั่นกาหนดความเร็วในการสื่ อสารทางพอร์ ตอนุกรม

6. ฟั งก์ ชั่นส่ งข้ อมู ลออกพอร์ ต เป็ นฟั งก์ชนั่ ที่ ใช้ในการส่ งข้อมู ลออกทางพอร์ ตอนุ กรมหรื อ
พิมพ์ขอ้ มูลออกทางพอร์ ตเพื่อแสดงผลที่จอคอมพิวเตอร์ เมื่อพิมพ์เสร็ จตัวเคอร์ เซอร์ จะรออยู่
ที่ทา้ ยสิ่ งที่พิมพ์น้ นั ๆ
Serial.print(val) Serial.print(val, format)
Serial.println(val) Serial.println(val, format)

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC R1-R3
SW1 220 LED1-LED3
1 AVCC
RST 4
C1 D2
0.1uF 5
D3
6
D4
R2,R3 11
DTR 3 VCC
RXD D1(TXD)
2
TXD D0(RXD)
+5V Internal pull up
GND
3V3 R4-R7
220 x4 SW1
15
D9
SW2
16
D10
SW3
17
X1 D11
16MHz 9 XTAL1 SW4
18
10 XTAL2 D12
C2,C3 GND
22pF 8,22

ARDUINO R1-R4 LED1-LED4
220
D2
D3
D4
D5
VCC
Internal pull up
R5-R8
220 x4 SW1
D9
SW2
D10
SW3
D11
SW4
D12
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D8
D7
D6
D5
D4
D3
D2
D0
D1
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A1
A2
A3
A4
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมการติดดับของ LED จานวน 2 ตัวใช้สวิตช์ 4 ตัวควบคุม โดยให้ SW1 สั่ง
LED1 ติด SW2 สัง่ LED1 ดับและให้ SW3 สัง่ LED2 ติด SW4 สัง่ LED2 ดับ
START
กาหนดค่าเริ ่มต้ นต่ า ง
จริ ง
SW1 ูก กด LED1 ติด
เท็จ
จริ ง
SW2 ูก กด LED1 ดับ
เท็จ
จริ ง
SW3 ูก กด LED2 ติด
เท็จ
จริ ง
SW4 ูก กด LED2 ดับ
เท็จ

1 #define LED1 2
2 #define LED2 3
3 #define SW1 9
4 #define SW2 10
5 #define SW3 11
6 #define SW4 12
7 void setup()
8 {
9 pinMode(LED1,OUTPUT);pinMode(LED2,OUTPUT);
10 pinMode(SW1,INPUT_PULLUP);pinMode(SW2,INPUT_PULLUP);
12 }
13 void loop()
14 {
15 if(digitalRead(SW1)==LOW)
23 }
- บรรทัดที่ 1-2 กาหนดชื่อ LED1, 2 ให้แทน 2, 3 (เป็ นขาที่ LED ต่ออยูก่ บั Arduino)
- บรรทัดที่ 3-6 กาหนดชื่อ SW1, 2, 3, 4 ให้แทน 9, 10, 11, 12 (เป็ นขาที่สวิตช์ต่ออยูก่ บั Arduino)
- บรรทัดที่ 9 กาหนดโหมดให้กบั ขาพอร์ ตที่ต่อกับ LED ทางานเป็ นเอาต์พุทพอร์ต
- บรรทัดที่ 10,11 กาหนดโหมดให้ขาพอร์ ตที่ต่อกับสวิตช์ทางานเป็ นอินพุทพอร์ ตที่ใช้ตวั ต้านทาน
พูลอัพภายในตัวไอซี ซ่ ึ งมีค่าประมาณ 20 กิโลโอห์ม
- บรรทัดที่ 15 ตราจสอบว่าสวิตช์ที่ต่อกับขาพอร์ ตที่ชื่อว่า SW1 ถูกกดหรื อไม่ (เมื่อถูกกดขาพอร์ ต
จะเป็ นลอจิก 0)
- บรรทัดที่ 16 หากสวิตช์ SW1 ถู กกดให้ส่งลอจิ ก 1 ออกทางขาพอร์ ตที่ ใช้ชื่อว่า LED1 เพื่อให้
LED ติดสว่าง
- บรรทัดที่ 17 หากการตรวจสอบเงื่อนไขในบรรทัดที่ 15 ผิดเงื่อนไขให้ทาการตราจสอบว่าสวิตช์
ที่ต่อกับขาพอร์ ตที่ชื่อว่า SW2 ถูกกดหรื อไม่
LED ดับ
การทดลองที่ 2 เขียนโปรแกรมควบคุมการติดดับของ LED โดยเมื่อ SW1 ถูกกดให้ LED1 ติด SW2 ถูก
กดให้ LED2 ติด SW3 ถูกกดให้ LED3 ติด SW4 ถูกกดให้ LED ดับทุกตัวและในขณะที่กดสวิตช์ตอ้ งมี
การแสดงข้อความแสดงว่าสวิตช์น้ ัน ๆ ถู กกดและสถานะของการติ ดดับของ LED และให้เขียนโค้ด
ตรวจจับการปล่อยคียก์ ่อนที่จะออกนอกลูป
START
จริ ง
SW1 ูก กด LED1 ติด แสดงข้ อความ SW1 ปล่ อ ยการกด
เท็จ
จริ ง
เท็จ
จริ ง
เท็จ
จริ ง
SW4 ูก กด LED ดับทั้งหมด แสดงข้ อความ SW1 ปล่ อ ยการกด
เท็จ

1 #define LED1 2
2 #define LED2 3
3 #define LED3 4
4 #define SW1 9
5 #define SW2 10
6 #define SW3 11
7 #define SW4 12
8 void setup(){
9 pinMode(LED1,OUTPUT);pinMode(LED2,OUTPUT);
14 }
15 void loop(){
16 if(digitalRead(SW1)==LOW){
18 Serial.println("SW1 is pressed & LED1 ON");
19 while(digitalRead(SW1)==LOW);
20 }
21 else if(digitalRead(SW2)==LOW){
25 }
30 }
35 Serial.println("SW4 is pressed & All LED is OFF");
37 }
38 }
- บรรทัดที่ 1-3 กาหนดชื่อ LED1, 2, 3 ให้แทน 2, 3, 4 (เป็ นขาที่ LED ต่ออยูก่ บั Arduino)
- บรรทัดที่ 4-7 กาหนดชื่อ SW1, 2, 3, 4 ให้แทน 9, 10, 11, 12 (เป็ นขาที่สวิตช์ต่ออยูก่ บั Arduino)
- บรรทัดที่ 9,10 กาหนดโหมดให้กบั ขาพอร์ ตที่ต่อกับ LED ทางานเป็ นเอาต์พุทพอร์ต
- บรรทัด ที่ 11,12 ก าหนดโหมดให้กบั ขาพอร์ ตที่ ต่อกับ สวิตช์ท างานเป็ นอิ นพุท พอร์ ตที่ ใช้ตวั
ต้านทานพูลอัพภายในตัวไอซี ซ่ ึ งมีค่าประมาณ 20k
- บรรทัดที่ 13 กาหนดอัตราเร็ วในการสื่ อสารข้อมูลของพอร์ ตอนุกรม
- บรรทัดที่ 16 ตราจสอบว่าสวิตช์ที่ต่อกับขาพอร์ ตที่ชื่อว่า SW1 ถูกกดหรื อไม่ (เมื่อถูกกดขาพอร์ ต
จะเป็ นลอจิก 0)
LED ติดสว่าง
- บรรทัดที่ 18 ส่ งข้อความไปแสดงผลที่จอคอมพิวเตอร์ ผา่ นพอร์ ตอนุกรมโดยแสดงคาว่า “SW1 is
pressed & LED1 ON”
- บรรทัดที่ 19 วนตรวจสอบว่ายังถูกกดอยูห่ รื อไม่หากยังถูกกดอยูใ่ ห้วนตรวจสอบจนกว่าจะมีการ
ปล่อยสวิตช์
- บรรทัดที่ 21 หากการตรวจสอบเงื่อนไขในบรรทัดที่ 16 ผิดเงื่อนไขให้ทาการตราจสอบว่าสวิตช์
ที่ ต่ อ กับ ขาพอร์ ต ที่ ชื่ อ ว่า SW2 ถู ก กดหรื อ ไม่ ต่ อ จากนั้น กระบวนการเป็ นเช่ น เดี ย วกับ การ
ตรวจสอบสวิตช์ SW1

1. ดัดแปลงการทดลองที่ 2 ให้ใช้วธิ ี การตรวจการปล่อยสวิตช์ครั้งเดียวดังโฟลว์ชาร์ต
START
จริ ง
SW1 ูก กด LED1 ติด แสดงข้ อความ
เท็จ
จริ ง
เท็จ
จริ ง
เท็จ
จริ ง
SW4 ูก กด LED ดับทั้งหมด แสดงข้ อความ
เท็จ
เท็จ
ปล่ อ ย SW แล้ ว
จริ ง
2. เขียนโปรแกรมควบคุ มการติ ดดับของ LED พร้ อมแสดงข้อความสถานะของสวิต ช์และ
LED โดยเงื่อนไขให้สวิตช์หนึ่งตัวควบคุมการติดดับของ LED 1 ตัว ตัวอย่างเช่นสวิตช์ SW1
กดครั้งที่ 1 ให้ LED1 ติดเมื่อกดครั้งที่ 2 ให้ LED1 ดับสลับกันไปต่อเนื่ องสวิตช์ตวั อื่น ๆ ก็
ทางานเช่นกันโดยใช้สวิตช์ 4 ตัวควบคุมการติดดับของ LED จานวน 4 ตัวใช้วงจรดังรู ป
220
D2
D3
D4
D5
VCC
Internal pull up
R5-R8
220 x4 SW1
D9
SW2
D10
SW3
D11
SW4
D12
GND

3. เขียนโปรแกรมไฟวิ่งจาก LED จานวน 4 ตัวโดยกาหนดรู ปแบบของไฟวิ่งจากสวิตช์จานวน

4 ใช้วงจรในการทดลองเช่ นเดี ยวกับข้อ 2 สาหรับรู ปแบบของไฟวิ่งสามารถกาหนดขึ้นมา
เองได้ ตัวอย่างของรู ปแบบไฟวิง่ LED 4 ตัวดังนี้
รู ปแบบ ลักษณะการวิง่
4
ใบงานที่ 4.5 การเขียนโปรแกรมอ่านค่าจากพอร์ตแอนาลอกและการใช้ PWM  89
การเขียนโปรแกรมอ่ านค่ าจากพอร์ ตแอนาลอกและการใช้ PWM
เพื่อให้สามารถเขียนโปรแกรมอ่านค่าจากพอร์ ตแอนาลอกและการใช้ PWMได้
1. บอกวิธีเขียนโปรแกรมอ่านค่าจากพอร์ ตแอนาลอกและการใช้ PWM ได้
2.1 Potentiometer 10k 1 ตัว 2.3 LED 3mm 4 ตัว
บอร์ ด Arduino รุ่ นที่ใช้ไอซี ไมโครคอนโทรลเลอร์ ATMEGA328, ATMEGA168, ATMEGA8
มีพอร์ตที่สามารถรับสัญญาณเข้าที่เป็ นสัญญาณแอนาลอกได้ 6 ช่อง ( 6 ขา) A0, A1, …A5 สาหรับบอร์ ด
ที่ใช้ไอซี ที่มีตวั ถัง DIP (ตัวถังตีนตะขาบ) เช่นบอร์ ดรุ่ น UNO และสามารถรับสัญญาณได้ 8 ช่องสาหรับ
บอร์ ดที่ใช้ชิพไอซี ที่มีตวั ถังแบบ SMD (อุปกรณ์ ผิวหน้า) เช่ น บอร์ ดรุ่ น Mini และ Nano ส่ วนบอร์ ดรุ่ น
Mega มีช่องสัญญาณที่สามารถสัญญาณแอนาลอกได้ 16 ช่อง ภายในตัวซีพียมู ีโมดูลแปลงสัญญาณแอนา
ลอกเป็ นดิ จิทลั ขนาด 10 บิ ต ดังนั้นเมื่ ออ่านค่ าเข้ามาซี พียูจะแปลงค่าได้เป็ นค่า ตั้ง แต่ 0 จนถึ ง 1023 ที่
ค่าแรงดันของสัญญาณแอนาลอกที่รับเข้ามาอยูใ่ นช่วง 0 ถึง 5 โวลต์
รู ปที่ 4.5-1 ตาแหน่งขาและหน้าที่ของซี พียู Arduino ชนิดตัวถังแบบ DIP
รู ปที่ 4.5-2 ตาแหน่งขาและหน้าที่ของซี พียู Arduino ชนิดตัวถังแบบ SMD

ขาพอร์ ต แอนาลอกจะมี บ างส่ ว นที่ ส ามารถน าไปใช้ง านแบบดิ จิ ทลั ได้ นั่น ก็ ห มายความว่า
สามารถใช้คาสัง่ digitalWrite( ), digitalRead( ) ได้เหมือนกับขาดิจิทลั ปกติ ขาพอร์ตแอนาลอกที่นามาใช้
งานในโหมดดิจิทลั ได้มีเพียง 6 ขาคือ A0, A1, …A5 ส่ วน A6 และ A7 ของบอร์ ดรุ่ น Mini และ Nano ใช้
รับสัญญาณเข้าที่เป็ นสัญญาณแอนาลอกเพียงอย่างเดียว ดังนั้นเมื่อใช้งานในโหมดดิจิทลั การใช้งานจะใช้
คาสั่งเดียวกันกับคาสั่งที่ควบคุมขาดิจิทลั เพียงแต่การระบุขาใช้งานจะต้องใส่ ช่องขาสัญญาณว่า A นาหน้า
เช่น
pinMode(A0,OUTPUT); หมายถึงให้ขา A0 ทางานในโหมดดิจิทลั ที่เป็ นเอาท์พุตพอร์ ต
digitalWrite(A0,HIGH); หมายถึงให้เขียนลอจิก 1 ไปที่ขาพอร์ต A0
Arduino มีขาพอร์ ตที่สามารถส่ งสัญญาณออกแบบผสมสัญญาณทางความกว้างของพัลซ์ได้ หรื อ

ที่เรี ยกว่า PWM โดยบอร์ ดที่ใช้ซีพียูเบอร์ Atmega168, Atmega328 (บอร์ ดรุ่ น UNO, Mini, Nano) มีขาที่
สามารถส่ งสัญญาณออกได้ 6 ขาคือ D3, D5, D6, D9, D10, และ D11 ความถี่ของสัญญาณ PWM จะมีค่า
โดยประมาณที่ 490 Hz ส่ วนค่าดิวติ้ไซเคิลสามารถใส่ ค่าได้ต้ งั แต่ 0-255 ใช้สาหรับกาหนดค่าดิวตี้ไซเคิล
ระหว่าง 0-100% ดังรู ป
Pulse Width Modulation
0% duty cycle -> analogWrite(0); 50% duty cycle -> analogWrite(127);
5V 5V
0V 0V
5V 5V
0V 0V
5V 5V
0V 0V
รู ปที่ 4.5-3 รู ปคลื่น PWM จากฟังก์ชนั่ analogWrite
ฟังก์ชนั่ ที่ส่งสัญญาณออกยังขาเหล่านี้ใช้คาสัง่
analogWrite(3, 100); หมายถึ ง ส่ ง สั ญ ญาณ PWM ออกทางขา D3 โดยให้สั ญ ญาณที่
ส่ งออกนั้นขนาดดิวตี้ไซเคิลที่ 100

pinMode(pin, mode)
2. ฟั งก์ ชั่นส่ งค่ าลอจิก ดิจิทัลไปยังขาพอร์ ต โดยค่า HIGH เป็ นการส่ งลอจิ ก 1 และค่า LOW
เป็ นการส่ งลอจิ ก 0 ออกไปยังขาพอร์ ต ซึ่ งฟั งก์ชั่นนี้ จะทางานได้จะต้องมี การใช้ฟังก์ชั่น
pinMode ก่อน

delay(ms)

Serial.begin(speed)
5. ฟั งก์ ชั่นส่ งข้ อมู ลออกพอร์ ต เป็ นฟั งก์ชั่นที่ ใช้ในการส่ งข้อมู ลออกทางพอร์ ตอนุ กรมหรื อ
6. ฟั งก์ ชั่นส่ งข้ อมู ลออกพอร์ ต คล้ายกับฟั งก์ชนั่ Serial.print ต่างกันตรงที่ เมื่ อพิมพ์เสร็ จ ตัว
7. ฟังก์ชั่นอ่านสั ญญาณแอนาลอก เป็ นฟังก์ชนั่ ที่อ่านสัญญาณแอนาลอกที่ปรากฏอยูท่ ี่ขาพอร์ ต

แอนาลอกที่ตอ้ งการอ่านนั้น ๆ ค่าที่อ่านได้จะอยูใ่ นช่วง 0-1023 สาหรับแรงดันของสัญญาณ
แอนาลอกที่ 0-5V ดังนั้นต้องใช้ตวั แปรที่เป็ น int สาหรับเก็บค่าที่อ่านได้
analogRead(pin)
pin: ขาพอร์ ตแอนาลอกที่ตอ้ งการอ่านค่าสัญญาณแอนาลอก
int adc analogRead(0) หมายถึง อ่านสัญญาณแอนาลอกที่ขา A0 นามาเก็บในตัวแปร adc
8. ฟังก์ชั่นให้ ขาพอร์ ตส่ งสั ญญาณ PWM เป็ นฟังก์ชนั่ ที่ให้ขาพอร์ ตดิจิทลั ขา 3, 5, 6, 9, 10 และ
11 (ซึ่ งเป็ นขาที่ส่งสัญญาณ PWM ได้) ส่ งสัญญาณ PWM ออกตามค่าดิ วติ้ไซเคิลที่กาหนด
ด้วยความถี่ 490 Hz
analogWrite(pin, value)
pin: ขาพอร์ตดิจิทลั ที่ตอ้ งการส่ งสัญญาณ PWM
value: ค่าดิวติ้ไซเคิลที่อยูร่ ะหว่าง 0 ถึง 255
analogWrite(3, 100); หมายถึงส่ งสัญญาณ PWM ออกทางขา D3 โดยให้สัญญาณ
ที่ส่งออกนั้นขนาดดิวตี้ไซเคิลที่ 100 ( ประมาณ 39.216 %)
9. ฟั งก์ ชั่นแปลงช่ วงตัวเลข เป็ นฟั งก์ชนั่ ทาหน้าที่เปลี่ ยนแปลงค่าที่ได้รับจากตัวแปรจากช่วง

ตัวเลขระหว่างค่าหนึ่งถึงอีกค่าหนึ่งไปสู่ ช่วงตัวเลขใหม่ที่ตอ้ งการ
map(value, fromLow, fromHigh, toLow, toHigh)
value: ตัวแปรที่ตอ้ งการอ่านค่านามาเปลี่ยนช่วงตัวเลข
fromLow: ตัวเลขสเกลล่างสุ ดของค่าจากตัวแปร
fromHigh: ตัวเลขสเกลสู งสุ ดของค่าจากตัวแปร
toLow: ตัวเลขสเกลล่างสุ ดของค่าที่ตอ้ งการเปลี่ยนไป
toHigh: ตัวเลขสเกลสู งสุ ดของค่าที่ตอ้ งการเปลี่ยนไป
int x map(y,0,1023,0,255)
หมายถึ ง แปลงค่าที่ อ่า นจากตัวแปร y เก็บลงในตัวแปร x โดยที่ ค่าตัวแปร y มี ค่าอยู่
ในช่วง 0-1023 โดยให้แปลงค่าไปสู่ ค่าใหม่ให้อยูใ่ นช่วง 0-255

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1 R4-R7
1 AVCC LED1-LED3
RST 220
C1 4
D2
0.1uF
5
(PWM)D3
6
D4
R2,R3
DTR 3 (PWM)D5
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
X1
16MHz 9 XTAL1 28
A5 10k
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
R1-R4 LED1-LED4
220
D2
(PWM)D3
D4
(PWM)D5
VCC
A5 10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

1. จากการจาลองการทางานด้วยโปรแกรม Proteus ขาพอร์ ต D3, D5, D6 ไม่มีสัญญาณ PWM
ออก แก้ไขโดยการเปลี่ยนไปใช้ขาพอร์ต D9, D10, D11 แทน
2. การทดลอง PWM เมื่อต่อโหลดด้วย LED จะไม่เห็นการเปลี่ ยนแปลงของระดับความสว่าง
แต่จะเห็นว่า LED กระพริ บ แก้ไขโดยการใช้สโคปจับสัญญาณเพื่อดูรูปคลื่นแทน
การทดลองที่ 1 เขียนโปรแกรมควบคุมระดับความสว่างของ LED ที่ต่ออยูท่ ี่ขาพอร์ ตดิจิทลั D9 ซึ่งเป็ นขา
ที่ สามารถส่ งสัญญาณ PWM ออกมาได้ด้วยคาสั่ง analogWrite(pin,value) โดยควบคุ มความสว่างด้วย
โพเทนธิ โอมิ เตอร์ ที่ ต่ออยู่ที่ข าพอร์ ตแอนาลอก A5 ค่าที่ อ่านได้จะมี ค่า อยู่ระหว่า ง 0-1023 แต่ค่าที่ ใ ช้
ควบคุมดิวตี้ไซเคิลอยูร่ ะหว่าง 0-255 การดาเนินการลดค่าให้ใช้ค่าที่อ่านได้หารด้วย 4 ก่อนเอาไปใช้งาน

START
กาหนดค่าเริ ่มต้ นต่ าง
อ่ านค่าจาก POT
เขียนค่ า PWM

1 #define LED 9 //LED Connected to D9
2 #define POT 5 //POT Connected to A5
3 void setup()
4 {
7 }
8 void loop()
9 {
10 int adc=analogRead(POT);
11 analogWrite(LED,adc/4);
12 }
- บรรทัดที่ 1 กาหนดชื่อ LED ให้แทน 9 (เป็ นขาที่ LED ต่ออยูก่ บั Arduino)
- บรรทัดที่ 2 กาหนดชื่อ POT ให้แทน 5 (เป็ นขาที่ Potentiometer ต่ออยูก่ บั Arduino)
- บรรทัดที่ 10 อ่านค่าแอนาลอกจาก POT โดยนาเข้ามาเก็บไว้ในตัวแปร adc
- บรรทัดที่ 11 เขียนค่าแอนาลอก (ส่ งสัญญาณพัลส์ แบบ PWM) ออกทางขาที่ใช้ชื่อว่า LED โดย
นาค่าตัวแปรที่เก็บค่าจาก POT มาหารด้วย 4 เนื่ องจากค่าที่อ่านจาก POT มีค่าสู งสุ ดที่ 1023 และ
ค่าที่กาหนด duty cycle ของฟังก์ชนั่ analogWrite มีค่าสู งสุ ดเพียง 255
การทดลองที่ 2 เขียนโปรแกรมควบคุมความสว่างแก่ LED จานวน 2 ตัวที่อยู่ที่ขา D9, D10 ซึ่ งเป็ นขาที่
สามารถส่ งสัญญาณ PWM ได้ โดยใช้โพเทนธิ โอมิเตอร์ เป็ นตัวปรับความสว่างโดยให้ LED ทั้งสองตัวมี
ความสว่างที่ตรงข้ามกัน โดยให้มีการแสดงค่าสัญญาณแอนาลอกที่อ่านได้จากขาที่ต่อโพเทนธิ โอมิเตอร์
ออกทางพอร์ตอนุกรมแสดงผลที่จอคอมพิวเตอร์
START
แสดงค่ าออกที่อ่านได้
เขียนค่ า PWM

1 #define LED1 9 //LED1 Connected to D9
2 #define LED2 10 //LED2 Connected to D10
3 #define POT 5 //POT Connected to A5
4 void setup()
5 {
9 }
10 void loop()
11 {
13 Serial.print("Analog Read value : ");
14 Serial.print(adc);
15 adc=map(adc,0,1023,0,255);
16 Serial.print(" map value to : ");
17 Serial.println(adc);
18 analogWrite(LED1,adc);
19 analogWrite(LED2,255-adc);
20 delay(500);
21 }
- บรรทัดที่ 1,2 กาหนดชื่อ LED1,2 ให้แทน 9,10 (เป็ นขาที่ LED ต่ออยูก่ บั Arduino)
- บรรทัดที่ 3 กาหนดชื่อ POT ให้แทน 5 (เป็ นขาที่ Potentiometer ต่ออยูก่ บั Arduino)
- บรรทัดที่ 6,7 กาหนดโหมดให้กบั ขาพอร์ ตที่ต่อกับ LED ทางานเป็ นเอาต์พุทพอร์ต
- บรรทัดที่ 12 อ่านค่าแอนาลอกจาก POT โดยนาเข้ามาเก็บไว้ในตัวแปร adc
- บรรทัดที่ 14 แสดงค่าที่อ่านได้จาก POT
- บรรทัดที่ 15 ใช้ฟังก์ชนั่ เปลี่ยนย่านตัวเลขของตัวแปรจาก 0-1023 ไปเป็ น 0-255

- บรรทัดที่ 18 เขียนค่าแอนาลอก (ส่ งสัญญาณพัลส์แบบ PWM) ออกทางขาที่ใช้ชื่อว่า LED1
- บรรทัดที่ 19 เขียนค่าแอนาลอก ซึ่ งเปลี่ยนแปลงค่าตัวเลขที่กาหนด duty cycle โดยใช้การคานวณ
ทางคณิ ตศาสตร์ ออกทางขาที่ ใช้ชื่อว่า LED2 (ใช้ 255 ลบออกจากค่าตัวแปรจะทาให้ค่ า duty
cycle ที่ได้ตรงข้ามกับค่าตัวแปรเดิม)

1. เขียนโปรแกรมไฟวิง่ LED 4 ตัว (กาหนดรู ปแบบเอง)โดยให้สามารถปรับความเร็ วในการวิ่ง
ได้ดว้ ยโพเทนธิโอมิเตอร์ วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
R1-R4 LED1-LED4
220
D2
(PWM)D3
D4
(PWM)D5
VCC
A5 10k
GND

ใบงานที่ 4.6 การเขียนโปรแกรมรับสวิตช์ทางพอร์ตแอนาลอก  99
การเขียนโปรแกรมรับสวิตช์ ทางพอร์ ตแอนาลอก
เพื่อให้สามารถเขียนโปรแกรมรับสวิตช์ทางพอร์ ตแอนาลอกได้
1. บอกวิธีเขียนโปรแกรมรับสวิตช์ทางพอร์ตแอนาลอกได้
2.1 ตัวต้านทาน 220 ohm 4 ตัว 2.5 ตัวต้านทาน 2.7k 1 ตัว
2.2 ตัวต้านทาน 1k 1 ตัว 2.6 LED 3mm 4 ตัว
2.3 ตัวต้านทาน 680 ohm 1 ตัว 2.7 Tack Switch 4 ตัว
สวิตช์ที่นามาใช้งานกับไมโครคอนโทรลเลอร์ จะเป็ นสวิตช์ชนิดกดติดปล่อยดับเมื่อนามาใช้งาน
จาเป็ นจะต้องใช้พอร์ ตในการเชื่ อมต่อ 1 ช่องต่อสวิตช์ 1 ตัว ดังใบงานรับค่าจากพอร์ ตดิจิทลั ที่ผา่ นมา ซึ่ ง
หากมีการใช้งานสวิตช์จานวนมากจานวนพอร์ ตก็จะยิง่ มากตาม ดังรู ป
ARDUINO VCC
Internal pull up
R1-R4
220 x4 SW1
D9
SW2
D10
SW3
D11
SW4
D12
GND
รู ปที่ 4.6-1 การต่อใช้งานสวิตช์กบั พอร์ ตดิจิทลั
ใบงานอ่านค่าจากพอร์ ตแอนาลอกที่ผา่ นมาเป็ นการเรี ยนรู ้เกี่ยวกับการใช้งานพอร์ ตที่รับสัญญาณ

เข้าที่ เป็ นแอนาลอกซึ่ งสามารถแยกความแตกต่างได้ 1024 ระดับในช่ องรั บเพียงช่ องเดี ยว ดังนั้นหาก
ผูใ้ ช้งานออกแบบวงจรสวิตช์ให้ต่อวงจรที่สามารถให้แรงดันที่แตกต่างกันได้เมื่อกดสวิตช์แต่ละตัว (ใช้
วงจรแบ่งแรงดัน) ก็สามารถใช้งานสวิตช์หลายตัวในพอร์ ตรับสัญญาณเพียงช่องเดียวได้ ดังรู ป
ARDUINO
VCC
R1
1k SW1
A0
R2
680 SW2
R3
820 SW3
R4
2.7k
GND SW4
รู ปที่ 4.6-2 การต่อใช้งานสวิตช์กบั พอร์ ตแอนาลอก


pinMode(pin, mode)

delay(ms)

Serial.begin(speed)
6. ฟั งก์ ชั่นส่ งข้ อมู ลออกพอร์ ต คล้ายกับฟั งก์ชั่น Serial.print ต่างกันตรงที่ เมื่ อพิมพ์เสร็ จ ตัว

แอนาลอกที่ 0-5V ดังนั้น ต้องใช้ตวั แปรที่เป็ น int สาหรับเก็บค่าที่อ่านได้
analogRead(pin)

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC R4-R7
SW1 220 LED1-LED3
1 AVCC
RST 4
C1 D2
0.1uF 5
D3
6
D4
R2,R3 11
DTR 3 VCC
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND R8
3V3 1k SW1
A0
R9
680 SW2
X1 R10
16MHz 9 820 SW3
XTAL1
10 XTAL2
C2,C3 GND R11
22pF 8,22 2.7k
SW4


220
D2
D3
D4
D5
VCC
R4
1k SW1
A0
R5
680 SW2
R6
820 SW3
R7
2.7k
GND SW4

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมอ่านค่าแอนาลอกจากการกดสวิตช์แต่ละตัวโดยแสดงผลที่จอคอมพิวเตอร์
ผ่านทางพอร์ ตอนุกรม

START
อ่ านค่าจากสวิตช์
แสดงค่ าที่อ ่านได้

1 #define sw 0 // switch connectec A0
2 void setup()
3 {
5 }
6 void loop()
7 {
8 int adc=analogRead(sw);
9 Serial.print("value from sw is: ");
11 delay(100);
12 }
- บรรทัดที่ 1 กาหนดชื่อ sw ให้แทน 0 (เป็ นขาที่วงจรสวิตช์ต่อเข้าที่ขา A0 ของ Arduino)
- บรรทัดที่ 8 อ่านค่าแอนาลอกจากวงจรสวิตช์โดยนาเข้ามาเก็บไว้ในตัวแปร adc
- บรรทัดที่ 10 แสดงค่าแอนาลอกจากการกดสวิตช์ผา่ นทางพอร์ ตอนุกรม
3. บันทึ ก ผลค่ า ที่ อ่า นได้จากการกดสวิ ต ช์ แ ต่ ล ะตัวและบันทึ ก ผลเพื่ อ นาไปใช้ง านในการ
ทดลองถัดไป
การกดสวิตช์ ไม่กดสวิตช์ กดสวิตช์ SW1 กดสวิตช์ SW2 กดสวิตช์ SW3 กดสวิตช์ SW4
ค่าที่อ่านได้
การทดลองที่ 2 เนื่ องจากค่าที่อ่านจากการกดสวิตช์เข้ามาทางพอร์ ตแอนาลอกมีโอกาสที่ตวั เลขจะแกว่ง

ได้ ดังนั้นหากเขียนโปรแกรมโดยวิธีการตรวจสอบการเท่ากันของค่าที่กาหนดมีโอกาสจะคลาดเคลื่อนได้
ทางแก้ปัญหาการแกว่งของค่าทาได้โดยเพิ่มช่วงในการตรวจสอบแทนที่จะตรวจสอบเพียงค่าเดียว การ
ทดลองนี้เป็ นการทดลองการกดสวิตช์ที่รับเข้ามาทางพอร์ ตแอนาลอกและมีการเพิม่ ช่วงในการตรวจสอบ
เป็ น 30 ค่าและแสดงผลเป็ นข้อความว่าสวิตช์ใดถูกกด
หมายเหตุ ค่าที่ใช้ตรวจสอบจะต้องใช้ผลจากการทดลองในการทดลองที่ 1 สาหรับตัวอย่างการทดลองที่

2 สมมุติวา่ ได้ค่าดังรู ปที่ 4.6-7 (สาหรับการทดลองจริ งให้ใช้ค่าจริ งที่ได้จากการทดลอง)
Value Value
1024 No sw presses 1024 No sw presses
827 sw4 is pressed 827 sw4 is pressed
0 sw1 is pressed Time 0 sw1 is pressed Time
รู ปที่ 4.6-7 การตรวจสอบแบบค่าเดียว รู ปที่ 4.6-8 การตรวจสอบแบบช่วง

START
อ่ านค่าจากพอร์ ต
จริ ง
อยู่ในช่ วงที่ 1 แสดงข้ อความ
เท็จ
จริ ง
เท็จ
จริ ง
เท็จ
จริ ง
เท็จ
แบบที่ 1 ตรวจสอบค่าที่อ่านได้แบบค่าเดียวไม่เพิ่มช่วงตรวจสอบ
2 void setup()
3 {
5 }
6 void loop()
7 {
9 if (adc==0)
10 {
11 Serial.print("SW1 is pressed : value adc is: ");
13 }
14 else if(adc==415)
15 {
18 }
20 {
23 }
25 {
28 }
29 delay(100);
30 }
- บรรทัดที่ 9 ตรวจสอบว่าใช่ค่าที่เกิดจากการกดสวิตช์ 1 หรื อไม่ (ถ้ากดค่าที่อ่านได้จะมีค่าเป็ น 0)
- บรรทัดที่ 11-12 แสดงค่าข้อความพร้ อมค่าที่อ่านจากพอร์ แอนาลอกจากการกดสวิตช์ผ่านทาง
พอร์ตอนุกรม
- บรรทัดที่ 14 หากไม่ใช่ เงื่ อนไขในบรรทัดที่ 9 ให้ตรวจสอบว่าใช่ ค่าที่ เกิ ดจากการกดสวิตช์ 2
หรื อไม่ (ถ้ากดค่าที่อ่านได้จะมีค่าเป็ น 415)
- บรรทัดที่ 19-28 ทากระบวนการตรวจสอบและแสดงผลเช่นเดียวกับบรรทัดที่ 14-17 แต่เป็ นการ
ตรวจสอบค่าจากการกดสวิตช์ 3 และ 4 ตามลาดับ
- บรรทัดที่ 29 หน่วงเวลา 100mS (1/10 วินาที)
แบบที่ 2 ตรวจสอบค่าที่อ่านได้ชนิดเพิ่มช่วงตรวจสอบ
2 #define range 30
3 void setup()
4 {
6 }
7 void loop()
8 {
10 if (adc<0+range)
11 {
14 }
15 else if((adc<415+range) && (adc>415-range))
16 {
19 }
21 {
24 }
26 {
29 }
30 delay(100);
31 }
- บรรทัดที่ 2 กาหนดชื่อ range ให้แทน 30 เป็ นค่าที่ใช้ในการเพิ่มช่วงการตรวจสอบ
- บรรทัดที่ 10 ตรวจสอบว่าใช่ค่าที่เกิดจากการกดสวิตช์ 1 หรื อไม่ โดยตรงสอบค่าตั้งแต่ช่วง 0-30
- บรรทัดที่ 15 หากไม่ใช่ เงื่ อนไขในบรรทัดที่ 9 ให้ตรวจสอบว่าใช่ ค่าที่ เกิ ดจากการกดสวิตช์ 2
หรื อไม่ โดยตรวจสอบค่าในช่วง 415 30
- บรรทัดที่ 20-28 ทากระบวนการตรวจสอบและแสดงผลเช่นเดียวกับบรรทัดที่ 15-18 แต่เป็ นการ
ตรวจสอบค่าจากการกดสวิตช์ 3 และ 4 ตามลาดับ
- บรรทัดที่ 30 หน่วงเวลา 100mS (1/10 วินาที)
3. สังเกตผลแล้วเปรี ยบเทียบความแตกต่างระหว่างทดสอบค่าเดียวกับแบบเพิม่ ช่วง

1. ปรับปรุ งโปรแกรมในการทดลองที่ 2 โดยให้สามารถตรวจสอบการปล่อยคียไ์ ด้ดว้ ย และให้
สวิตช์แต่ละตัวควบคุมการติดดับของ LED ดังนี้
สวิตช์ที่ถูกกด ผลที่ตอ้ งการ
SW1 LED 1 ติดสว่าง พร้อมแสดงข้อความ
SW4 LED ทุกตัวดับทั้งหมด พร้อมแสดงข้อความ

220
D2
D3
D4
D5
VCC
R4
1k SW1
A0
R5
680 SW2
R6
820 SW3
R7
2.7k
GND SW4

ใบงานที่ 4.7 การเขียนโปรแกรมวัดอุณหภูมิดว้ ยเทอร์มิสเตอร์ชนิด NTC  109
การเขียนโปรแกรมวัดอุณหภูมดิ ้ วยเทอร์ มสิ เตอร์ ชนิด NTC
เพื่อให้สามารถเขียนโปรแกรมวัดอุณหภูมิดว้ ยเทอร์มิสเตอร์ชนิด NTC ได้
1. บอกวิธีเขียนโปรแกรมวัดอุณหภูมิดว้ ยเทอร์มิสเตอร์ชนิด NTC ได้
2.1 ตัวต้านทาน 10k 1 ตัว 2.3 LED 3mm 4 ตัว
2.2 ตัวต้านทาน 220 ohm 4 ตัว 2.4 Thermistor NTC 10k 1 ตัว
เทอร์มิสเตอร์ (Thermistor) เป็ นตัววัดอุณหภูมิแบบสารกึ่งตัวนาที่ใช้หลักการการเปลี่ยนแปลง
ความต้านทานเมื่ออุณหภูมิเปลี่ยนไปโดยมีดว้ ยกัน 2 แบบคือ
1. NTC (Negative Temperature Coefficient) มีคุณสมบัติแปรผันผกผันกับอุณหภูมิ กล่าวคือ
เมื่ออุณหภูมิสูงขึ้นค่าความต้านทานจะลดต่าลง
2. PTC (Positive Temperature Coefficient) มีคุณสมบัติแปรผันตรงกับอุณหภูมิ กล่าวคือเมื่อ
อุณหภูมิสูงขึ้นค่าความต้านทานจะสู งขึ้นตาม
ในทางปฏิบตั ิเทอร์ มิสเตอร์ ที่มีจาหน่ายในท้องตลาดส่ วนใหญ่ที่พบมากจะเป็ นชนิด NTC ใบงาน
นี้เป็ นใบงานที่นาเทอร์ มิสเตอร์ ชนิ ดนี้มาใช้งาน โดยการนามาใช้งานจะใช้เทอร์มิสเตอร์ NTC ที่มีค่าความ
ต้านทานที่ 10k ที่อุณหภูมิหอ้ ง (25 C) อนุกรมกับตัวต้านทานขนาด 10k เป็ นวงจรแบ่งแรงดันดังรู ป
VCC
10k
T
Thermistor
10k
รู ปที่ 4.7-1 วงจรแบ่งแรงดันในการนาเทอร์ มิสเตอร์ ไปใช้งาน
ค่ า แรงดันที่ ไ ด้ส่ ง เข้า ไปยัง ขาพอร์ ตแอนาลอกเพื่ ออ่ า นค่ า เข้า ซี พี ยูเพื่ อ นาไปค านวณเป็ นค่ า
อุณหภูมิต่อไป โดยสมการของวงจรเป็ นดังนี้
สมการวงจรแบ่ งแรงดัน
RNTC
ADC =  1023
10k  RNTC
10k  RNTC 1023
=
RNTC ADC
1023RNTC
10k  RNTC =
ADC
1023RNTC
10k =  RNTC
ADC
 1023 
10k = RNTC   1
 ADC 
10k
RNTC =
 1023 
  1
 ADC 
สมการอุณหภูมิ
1 1 1  RNTC 
=  ln  
T T0 B  RNTC 0 
เมื่อ T อุณหภูมิหน่วยเป็ นเคลวิน
T0 อุณหภูมิหอ้ งปกติที่ 25 องศาเซลเซี ยสหน่วยเป็ นเคลวิน (25+273.15)
B ค่าสัมประสิ ทธิ์ ของเทอร์ มิสเตอร์ NTC มีค่าเป็ น 3950
RNTC0 ค่าความต้านทานของเทอร์ มิสเตอร์ NTC ที่อุณหภูมิห้องปกติมีค่าเท่ากับ 10k

pinMode(pin, mode);
ส่ งลอจิก 0 ออกไปยังขาพอร์ต ฟังก์ชนั่ นี้จะทางานได้ตอ้ งมีการใช้ฟังก์ชนั่ pinMode ก่อน

delay(ms);

Serial.print(val); Serial.print(val, format);
Serial.println(val); Serial.println(val, format);

analogRead(pin);
int ADC analogRead(0) หมายถึง อ่านสัญญาณแอนาลอกที่ขา A0 นามาเก็บในตัวแปร ADC

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1 R4-R7
0.1uF 220 LED1-LED3
4
D2
5
D3
R2,R3
DTR 3 D4
RXD D1(TXD)
2 11
TXD D0(RXD) D5
+5V
GND
3V3
VCC
R8
X1 10k
16MHz 9 28
XTAL1 A5
10 XTAL2 NTC
T
Thermistor
C2,C3 GND 10k
22pF 8,22

ARDUINO
R1-R4 LED1-LED4
220
D2
D3
D4
D5
VCC
R5
10k
A5
NTC
T
Thermistor
10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1


หมายเหตุ โปรแกรมจาลองบางเวอร์ ชนั่ อาจจาลอง NTC ไม่ได้ (เช่น 7.10) ให้เปลี่ยนไปใช้เวอร์ ชนั่ อื่นที่
สามารถจาลองได้ (เช่น 8.60)
การทดลองที่ 1 เขียนโปรแกรมอ่านค่าจากเทอร์ มิสเตอร์ NTC ขนาด 10k โดยให้แสดงผลเป็ นอุณหภูมิที่มี
หน่วยเป็ นเซสเซี ยส (เขียนโค้ดจากสมการในทฤษฎี) แสดงผลที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
START
อ่ านค่าจาก NTC
คานวณ
แสดงผล

1 #define NTCPin A5
2 #define SERIESRESISTOR 10000
3 #define NOMINAL_RESISTANCE 10000
4 #define NOMINAL_TEMPERATURE 25
5 #define BCOEFFICIENT 3950
6 void setup()
7 {
9 }
10 void loop()
11 {
12 float ADCvalue;
13 float Resistance;
14 float steinhart;
15 ADCvalue = analogRead(NTCPin);
16 Resistance = (1023 / ADCvalue) - 1;

17 Resistance = SERIESRESISTOR / Resistance;
18 steinhart = Resistance / NOMINAL_RESISTANCE; // (R/Ro)
19 steinhart = log(steinhart); // ln(R/Ro)
20 steinhart /= BCOEFFICIENT; // 1/B * ln(R/Ro)
21 steinhart += 1.0 / (NOMINAL_TEMPERATURE + 273.15); // + (1/To)
22 steinhart = 1.0 / steinhart; // Invert
23 steinhart -= 273.15; // convert to C
25 Serial.print(steinhart);
27 delay(1000);
28 }
- บรรทัดที่ 1 กาหนดชื่อ NTCPin ให้แทน A5 (เป็ นขาที่วงจร NTC ต่อเข้าที่ขา A5 ของ Arduino)
- บรรทัดที่ 2-5 กาหนดชื่ อแทนค่าคงที่ ต่าง ๆ ที่ ใช้ในการคานวณค่าที่ อ่านได้จาก NTC มาเป็ น
ตัวเลขอุณหภูมิ
- บรรทัดที่ 12-14 กาหนดตัวแปรที่สามารถเก็บตัวเลขทศนิยมได้เอาไว้เก็บค่าเมื่อคานวณค่าที่อ่าน
ได้จาก NTC มาเป็ นตัวเลขอุณหภูมิ
- บรรทัดที่ 15 อ่านค่าแอนาลอกจากวงจร NTC มาเก็บลงในตัวแปร ADCvalue
- บรรทัดที่ 16-23 คานวณค่าที่อ่านได้จาก NTC มาเป็ นตัวเลขอุณหภูมิ โดยเก็บค่าอุณหภูมิที่เป็ น
องศาเซลเซียสไว้ในตัวแปร Steinhart
- บรรทัดที่ 25 แสดงค่าอุณภูมิจากตัวแปร Steinhart ที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
3. ทดลองเพิ่ม/ลด อุณหภูมิที่ตวั เทอร์ มิสเตอร์ สังเกตค่าอุณหภูมิที่อ่านได้
การทดลองที่ 2 เขียนโปรแกรมอ่านค่าจากเทอร์ มิสเตอร์ NTC ขนาด 10k โดยให้แสดงผลเป็ นอุณหภูมิที่มี

หน่วยเป็ นเซสเซี ยส (เขียนแบบย่อ) แสดงผลที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
START
อ่ านค่าอุณหภูมิ
แสดงผล

1 #define NTC A5
2 double Thermistor(int RawADC) ;
3 void setup()
4 {
6 }
7 void loop()
8 {
11 Serial.print(Temp);
13 delay(1000);
14 }
16 {
17 double Cal;
18 Cal = log(10000.0/((1024.0/RawADC-1)));
19 Cal = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Cal * Cal))* Cal);
21 return Cal;
22 }
- บรรทัดที่ 1 กาหนดชื่อ NTCPin ให้แทน A5 (เป็ นขาที่วงจร NTC ต่อเข้าที่ขา A5 ของ Arduino)
- บรรทัดที่ 2 ประกาศรู ปแบบของฟังก์ชนั่ รองที่ใช้คานวณค่าอุณหภูมิ
- บรรทัดที่ 9 ประกาศตัวแปรและเรี ยกใช้ฟังก์ชนั่ รองโดยการส่ งค่าจากการอ่านค่าจากขาพอร์ ต
แอนาลอกที่ต่อกับเทอร์ มิสเตอร์ NTC ด้วยฟั งก์ชนั่ analogRead (ฟั งก์ชนั่ ซ้อนฟั งก์ชั่น)โดยให้
ฟังก์ชนั่ รองทาการคานวณค่าที่อ่านได้ไปเป็ นค่าอุณหภูมิที่เป็ นองศาเซลเซี ยสแล้วให้ส่งเข้าไปยัง
ตัวแปร Temp
- บรรทัดที่ 11 แสดงค่าอุณภูมิจากตัวแปร Temp ที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
- บรรทัดที่ 15-22 เป็ นฟั งก์ชนั่ รองที่ใช้คานวณค่าที่ส่งเข้ามาให้เป็ นค่าอุณหภูมิเป็ นองศาเซลเซี ยส
แล้วกลับคืนค่าออกนอกฟังก์ชนั่ ด้วยค่าในตัวแปร Cal ซึ่ งเป็ นค่าอุณหภูมิเป็ นองศาเซลเซี ยส
3. สังเกตข้อแตกต่างของอุณภูมิเมื่อเทียบกับการทดลองที่ 1
4. ทดลองเพิ่ม/ลด อุณหภูมิที่ตวั เทอร์ มิสเตอร์ สังเกตค่าอุณหภูมิที่อ่านได้

1. เขียนโปรแกรมควบคุมการติดดับของ LED 4 ตัวตามอุณหภูมิ ให้สามารถติดหรื อดับทั้งหมด
ในช่วงอุณหภูมิที่สามารถทดลองได้ วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
R1-R4 LED1-LED4
220
D2
D3
D4
D5
VCC
R5
10k
A5
NTC
T
Thermistor
10k
GND

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

2. เขียนโปรแกรมวัดค่าอุณหภูมิโดยใช้เทอร์ มิสเตอร์ 2 ตัวแล้วเปรี ยบเทียบความแตกต่างของ

อุณหภูมิที่วดั ได้ วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
VCC
R1
10k
A4
NTC
T
Thermistor
10k
VCC
R2
10k
A5
NTC
T
Thermistor
10k
GND
บันทึกผลลงตาราง
ค่าที่ อุณหภูมิที่วดั จาก NTC ตัวที่ 1 อุณหภูมิที่วดั จาก NTC ตัวที่ 2
1
2
3
4
5
ใบงานที่ 4.8 การเขียนโปรแกรมวัดอุณหภูมิและความชื้นด้วยโมดูล DHT22  119
การเขียนโปรแกรมวัดอุณหภูมแิ ละความชื้นด้ วยโมดูล DHT22
เพื่อให้สามารถเขียนโปรแกรมวัดอุณหภูมิและความชื้นด้วยโมดูล DHT22 ได้
1. บอกวิธีเขียนโปรแกรมวัดอุณหภูมิและความชื้นด้วยโมดูล DHT22 ได้
2.1 ตัวต้านทาน 4.8 k 1 ตัว 2.3 LED 3mm 2 ตัว
4. โมดูลวัดอุณหภูมิ DHT22 1 ตัว
การวัดอุ ณหภู มิและความชื้ นสัมพัทธ์ ปั จจุ บนั มี เซนเซอร์ ชนิ ดหนึ่ งที่ ถูกออกแบบมาทางานนี้
โดยเฉพาะเซนเซอร์ ตวั นั้นคือ DHT11 และ DHT22 ซึ่ งทั้งสองเป็ นโมดูลที่ทางานแบบเดียวกันทุกประการ
เป็ นอุปกรณ์ที่ใช้ขาสื่ อสารเพียงเส้นเดียวเป็ นการสื่ อสารสองทิศทางและเป็ นการสื่ อสารที่ให้ขอ้ มูลแบบ
ดิจิทลั ความแตกต่างกันของโมดูลทั้งสองเป็ นดังตาราง
DHT11 DHT22
1. Ultra low cost 1. Low cost
2. 3 to 5V power and I/O 2. 3 to 5V power and I/O
3. 2.5mA max current use during conversion 3. 2.5mA max current use during conversion
(while requesting data) (while requesting data)
4. Good for 20-80% humidity readings with 5% 4. Good for 0-100% humidity readings with 2-5%
accuracy accuracy
5. Good for 0-50°C temperature readings ±2°C 5. Good for -40 to 125°C temperature readings
accuracy ±0.5°C accuracy
6. No more than 1 Hz sampling rate (once every 6. No more than 0.5 Hz sampling rate (once every
second) 2 seconds)
7. Body size 15.5mm x 12mm x 5.5mm 7. Body size 15.1mm x 25mm x 7.7mm
8. 4 pins with 0.1" spacing 8. 4 pins with 0.1" spacing
จากตารางเปรี ยบเทียบจะเห็นความแตกต่างของโมดูลวัดอุณหภูมิและความชื้ นสัมพัทธ์ท้ งั สอง

เบอร์ ได้พอสมควร ใบงานนี้ เลื อกใช้เบอร์ DHT22 (เวลาเขียนโค้ดโปรแกรมไม่ต่างกัน) รู ปร่ างหน้าตา
และขนาดของโมดูลตลอดจนหน้าที่ของแต่ละขาเป็ นดังรู ป
รู ปที่ 4.8-1 รู ปร่ างของโมดูลวัดอุณหภูมิและความชื้นสัมพัทธ์ DHT22
การต่ อใช้ง านโมดู ล DHT11, DHT22 จะต้องใช้ตวั ต้า นทานพู ล อัพ ที่ ข าสั ญญาณข้อมู ลที่ มีค่า
เท่ากับ 4.7k ดังรู ป
3.3V-6V
4k7 DHT22
MCU DATA
รู ปที่ 4.8-2 การต่อใช้งานโมดูล DHT11, DHT22

การเขี ย นโค้ด โปรแกรมเพื่ อ อ่ า นค่ า อุ ณ หภู มิ แ ละความชื้ น สั ม พัท ธ์ ท้ งั DHT11 และ DHT22
ปั จจุบนั มีไลบรารี่ ช่วยงานทาให้ผูเ้ ขียนโค้ดสามารถเขียนโค้ดได้ง่ายขึ้น ซึ่ งไลบรารี่ ที่ตอ้ งเอามาใช้งาน
เพื่ออ่านค่าจากโมดูลดังกล่าวจะต้องใช้ไลบรารี่ 2 ตัว โดยสามารถดาวน์โหลดได้ที่
ไลบรารี่ แหล่งดาวน์โหลด
DHT.h https://github.com/adafruit/DHT-sensor-library
Adafruit_Sensor.h https://github.com/adafruit/Adafruit_Sensor
มีข้ นั ตอนการดาเนิ นการเพื่อนาไลบรารี่ มาใช้งานดังนี้

1. ดาวน์โหลดไลบรารี่ ตวั ที่ 1 ซึ่ งเป็ นไฟล์ Zip ดังรู ป
รู ปที่ 4.8-2 การดาวน์โหลดไลบรารี่ ที่นามาใช้งานตัวที่ 1
2. ดาวน์โหลดไลบรารี่ ตวั ที่ 2 ซึ่ งเป็ นไฟล์ Zip ดังรู ป
3. ทาการเพิ่มไลบรารี่ ท้ งั 2 ลงในโปรแกรม Arduino IDE โดยการเพิ่มจากไฟล์ zip แล้วทาการหา

ไฟล์ zip ที่ได้จากการดาวน์โหลดในข้อ 1 และ 2
รู ปที่ 4.8-4 การเพิ่มไลบรารี่ ที่เป็ นไฟล์ zip ลงในโปรแกรม Arduino IDE


delay(ms);
ฟังก์ชั่นใช้ งานของไลบรารี่ DHT

การอ่านค่าจากโมดูล DHT จาเป็ นต้องใช้ไลบรารี่ ช่วยงาน ซึ่ งไลบรารี่ ไม่ได้ถูกเพิ่มเข้ามาในตัว
โปรแกรม Arduino IDE ตั้งแต่แรกจาเป็ นต้องติดตั้งเพิ่มเติม โดยมีฟังก์ชนั่ ให้ใช้งานดังนี้
1. ฟังก์ ชั่นกาหนดขาเชื่ อมต่ อ ใช้ในการระบุขาที่ใช้เชื่ อมต่อให้ตวั โปรแกรมรับรู ้ รู ปแบบเป็ น

ดังนี้
DHT dht(DHTPIN, DHTTYPE);
DHTPIN: ตัวเลขระบุขาพอร์ ตที่ใช้เชื่อมต่อกับโมดูล
DHTTYPE: ชนิดของโมดูลที่เชื่อมต่อได้แก่ DHT11, DHT21, DHT22
DHT dht(8, DHT22);
หมายถึ ง ต่ อไปในโปรแกรมจะใช้ชื่ อ dht ในการเรี ย กใช้ง านโมดู ล โดยมี ก ารเชื่ อมต่อ
สายสัญญาณเข้าที่ขาพอร์ต D8 และใช้โมดูลชนิด DHT22
2. ฟังก์ ชั่นอ่ านค่ าความชื้น ค่าที่ได้จากฟั งก์ชนั่ อยูใ่ นรู ปของตัวแปร float หน่วยเป็ นเปอร์ เซนต์
ของความชื้นในอากาศที่วดั ได้ รู ปแบบของฟังก์ชนั่ ดังนี้
dht.readHumidity();
3. ฟังก์ ชั่นอ่ านค่ าความอุณหภูมิ ค่าที่ได้จากฟั งก์ชนั่ อยูใ่ นรู ปของตัวแปร float หน่วยเป็ นองศา
เซลเซียส รู ปแบบของฟังก์ชนั่ ดังนี้
dht.readTemperature();
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1 VCC
0.1uF
R4 DHT22
4k7
D8 14 DATA
R2,R3
USB to UART (TTL Level) 1k
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
VCC
R1 DHT22
4k7
D8 DATA
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1

การทดลองที่ 1 เขี ย นโปรแกรมอ่ า นค่ า อุ ณ หภู มิ และความชื้ นสั ม พัท ธ์ จ ากโมดู ล DHT22 แสดงผลที่
จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
START
อ่ านค่าจากโมดูล DHT22
แสดงผล

1 #include <DHT.h>
2 #define DHTPIN 8 // pin to connect DHT22
3 #define DHTTYPE DHT22 // Type of use DHT11,DHT21,DHT22
4
5 DHT dht(DHTPIN, DHTTYPE);
6 void setup()
7 {
9 Serial.println("DHTxx test!");
10 dht.begin();
11 }
12 void loop()
13 {
14 delay(2000);
15 float h = dht.readHumidity();
16 float t = dht.readTemperature();
17 if (isnan(h) || isnan(t))
18 {
19 Serial.println("Failed to read from DHT sensor!");
20 return;
21 }
22 Serial.print("Humidity: ");
23 Serial.print(h);
24 Serial.print(" %\t");
25 Serial.print(" Temperature: ");
26 Serial.print(t);
27 Serial.println(" *C ");
28 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ DHT.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 กาหนดชื่อ DHTPIN ให้แทน 8 (เป็ นขาที่ DHT22 ต่อเข้าที่ขา D8 ของ Arduino)
- บรรทัด ที่ 3 ก าหนดชื่ อ DHTTYPE ให้แทน DHT22 เมื่ อวงจรต่ อใช้ง านโมดู ล DHT22 แต่ ถ้า
ผูใ้ ช้งานใช้โมดูล DHT11 หรื อ DTH21 ให้เปลี่ยนการกาหนดชื่อตาม
- บรรทัดที่ 5 ประกาศใช้งานไลบรารี่ โดยสามารถกาหนดชื่ อเรี ยกโมดูลตามต้องการได้ตวั อย่างนี้
กาหนดชื่อเรี ยกเป็ น dht

- บรรทัดที่ 10 สั่งให้ไลบรารี่ DHT.h เริ่ มทางานโดยใช้ชื่อเรี ยกโมดูลว่า dht
- บรรทัดที่ 15 เรี ยกใช้ฟังก์ชนั่ อ่านค่าความชื้นที่ตรวจวัดได้แล้วเอามาเก็บไว้ในตัวแปร h
- บรรทัดที่ 16 เรี ยกใช้ฟังก์ชนั่ อ่านค่าอุณหภูมิที่ตรวจวัดได้แล้วเอามาเก็บไว้ในตัวแปร t
- บรรทัดที่ 17 ตรวจสอบค่าในตัวแปร h และ t ว่ามีตวั ใดตัวหนึ่งหรื อทั้งสองตัวมีค่าที่ไม่ใช่ตวั เลข
หรื อไม่
- บรรทัดที่ 19-20 หากตรวจสอบจากบรรทัดที่ 17 แล้วพบว่ามี ค่าของตัวแปรที่ ไม่ใช่ ตวั เลขให้
แสดงข้อความพร้อมกลับให้ออกไปเริ่ มต้นใหม่
- บรรทัดที่ 23,26 แสดงค่าความชื้นจากตัวแปร h และค่าอุณหภูมิจากตัวแปร t
3. ทดลองเพิ่ม/ลด อุณหภูมิและความชื้นสัมพัทธ์ที่ตวั โมดูล สังเกตค่าที่อ่านได้

1. เขี ย นโปรแกรมควบคุ ม การติ ด ดับ ของ LED 2 ตัว ให้ LED1 ถู ก ควบคุ ม การติ ด ดับ ตาม
อุณหภูมิและ LED2 ถู กควบคุ มการติดดับตามความชื้ นสัมพัทธ์ โดยใช้สามารถติดหรื อดับ
ทั้งหมดตามอุณหภูมิและความชื้นที่สามารถทดลองได้ วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO VCC
R1 DHT22
4k7
D8 DATA
R2
220 LED1
D3
R3
220 LED2
D2
GND

ใบงานที่ 4.9 การเขียนโปรแกรมใช้งานไอซีวดั อุณหภูมิ DS18B20  127
การเขียนโปรแกรมใช้ งานไอซีวดั อุณหภูมิ DS18B20
เพื่อให้สามารถเขียนโปรแกรมใช้งานไอซีวดั อุณหภูมิ DS18B20ได้
1. บอกวิธีเขียนโปรแกรมใช้งานไอซีวดั อุณหภูมิ DS18B20ได้
2. อุปกรณ์อิเล็กทรอนิกส์ประกอบด้วย
2.1 ตัวต้านทาน 220 ohm 4 ตัว 2.3 LED 3mm 4 ตัว
2.2 ตัวต้านทาน 4.7k 2 ตัว 2.4 ไอซี DS18B20 2 ตัว
ไอซี ที่ถูกออกแบบมาสาหรับวัด อุณหภูมิมีอยูห่ ลายแบบ ถ้าแบ่งตามสัญญาณเอาต์พุตจะแบ่งได้
เป็ นสองประเภทคือ ไอซี ที่ให้เอาต์พุตแบบแอนาลอกและไอซี ที่ให้ค่าออกมาเป็ นดิจิทลั โดยไอซี แบบ
ดิจิทลั จะส่ งค่าออกมาเป็ นตัวเลขของอุณหภูมิซ่ ึ งผูใ้ ช้งานสามารถนาค่าไปใช้งานได้โดยตรงไม่ตอ้ งผ่าน
กระบวนการคานวณค่าเช่นไอซี ที่ให้ค่าที่เป็ นแอนาลอกอีก
ไอซี DS1820 เป็ นไอซี ถูกออกแบบมาสาหรับวัดอุณหภูมิโดยให้ค่าออกมาเป็ นแบบดิจิทลั และใช้
การสื่ อสารแบบ 1 เส้นสัญญาณหรื อที่ เรี ยกว่า “One wire” การสื่ อสารลักษณะนี้ ไม่ตอ้ งมีสายสั ญญาณ
นาฬิกามาควบคุมจังหวะการถ่ายทอดข้อมูลเหมือนกับระบบสื่ อสารข้อมูลอนุ กรมในแบบอื่น ดังนั้นหาก
การใช้งานที่ตอ้ งเดินสายในระยะไกลจึงมีความสะดวกในการใช้งาน
คุณลักษณะทัว่ ไป
- DS1820 เป็ นไอซี ดิจิทลั เทอร์ โมมิเตอร์ใช้การอินเตอร์เฟสแบบ 1-Wire ไอซี ตระกูลนี้มีหลาย
เบอร์ ขึ้นอยูก่ บั ค่าความละเอียดเช่น
• DS1820 ค่าที่อ่านได้ 9–bit ความละเอียด 0.5 °C
• DS18B20 ค่าที่อ่านได้ 12–bit ความละเอียด 0.0625 °C
- ใช้แรงดันไฟเลี้ยงได้ในช่วง 3.0V ถึง 5.5V
- ย่านการวัดตั้งแต่ –55°C ถึง +125°C หรื อ –67°F ถึง +257°F ความเที่ยงตรง 0.5°C
- ใช้เวลาการแปลง 200 ms สาหรับข้อมูล 9 บิต และ750 ms สาหรับข้อมูล 12 บิต
- มี 3 ขา คือ Gnd, DQ, Vdd
- ใช้งานได้สองแบบ: normal mode (ใช้ท้ งั 3 ขา) และ parasite power mode (ใช้เพียง 2 ขา คือ
DQ และ GND ในขณะที่ขา Vdd จะต่อกับขา Gnd)
- สามารถนาไอซี มาพ่วงต่อกันในบัสเดียว (เส้นสัญญาณ DQ) ได้หลายอุปกรณ์
รู ปที่ 4.9-1 ไอซี DS18B20

การเขีย นโค้ดโปรแกรมเพื่ออ่านค่าอุ ณหภู มิจากไอซี วดั อุ ณหภู มิ DS18B20 ปั จจุบนั มีไลบรารี่

ช่วยงานทาให้ผเู ้ ขียนโค้ดสามารถเขียนโค้ดได้ง่ายขึ้น ซึ่ งไลบรารี่ ที่ตอ้ งเอามาใช้งานเพื่อที่จะอ่านค่าจาก
โมดูลดังกล่าวจะต้องใช้ไลบรารี่ 2 ตัว โดยสามารถดาวน์โหลดได้ที่
OneWire.h https://github.com/PaulStoffregen/OneWire
DallasTemperature.h https://github.com/milesburton/Arduino-Temperature-Control-Library

1. ดาวน์โหลดไลบรารี่ OneWire.h เป็ นไฟล์ Zip ดังรู ป
2. ดาวน์โหลดไลบรารี่ DallasTemperature.h เป็ นไฟล์ Zip ดังรู ป

รู ปที่ 4.9-4 การเพิม่ ไลบรารี่ ที่เป็ นไฟล์ zip ลงในโปรแกรม Arduino IDE

โหมดดิจิทลั รู ปแบบของฟังก์ชนั่ เป็ นดังนี้
pinMode(pin, mode);
value: HIGH or LOW
delay(ms);
4. ฟังก์ชั่นหน่ วงเวลาเป็ นไมโครวินาที เนื่องจากฟั งก์ชนั่ หน่วงเวลาปกติเวลาต่าสุ ดที่ทาได้คือ 1
มิลลิวนิ าที ดังนั้นหากต้องการหน่วงเวลาที่ต่ากว่าจึ่งต้องใช้ฟังชัน่ นี้ซ่ ึ งสามารถหน่วงเวลาได้
ในระดับไมโครวินาที รู ปฟังชัน่ เป็ นดังนี้
delayMicroseconds(us);
us: ตัวเลขที่หยุดค้างของเวลาหน่วยไมโครวินาที (unsigned int)
5. ฟังก์ชั่นกาหนดความเร็วในการสื่ อสารทางพอร์ ตอนุกรม
ฟังก์ชั่นใช้ งานของไลบรารี่ OneWire.h

การอ่านค่าจากไอซี DS18B20 จาเป็ นต้องใช้ไลบรารี่ สื่อสารแบบ One wire ช่ วย โดยมีฟังก์ชนั่
ให้ใช้งานดังนี้
ฟังก์ชั่นกาหนดขาเชื่ อมต่ อ ใช้ในการระบุขาที่ใช้เชื่อมต่อให้ตวั โปรแกรมรับรู ้ รู ปแบบเป็ นดังนี้
OneWire name(pin);
name: ชื่อของอุปกรณ์ที่เชื่อมต่อทางพอร์ ตที่สื่อสารแบบ One wire
pin: ขาพอร์ตดิจิทลั ที่เชื่อมต่อกับขา DQ ของไอซี DS18B20
ตัวอย่างเช่ น OneWire ds(2);
หมายถึง ต่อไปในโปรแกรมจะใช้ชื่อ ds ในการเรี ยกใช้งานอุปกรณ์ ที่มีการเชื่ อมต่ อ
สายสัญญาณเข้าที่ขาพอร์ต D2
ฟังก์ชั่นใช้ งานของไลบรารี่ DallasTemperature.h
การอ่านค่าจากไอซี DS18B20 จาเป็ นต้องใช้ไลบรารี่ ช่วยงาน ซึ่ งไลบรารี่ ไม่ได้ถูกเพิ่มเข้ามาใน
ตัวโปรแกรม Arduino IDE ตั้งแต่แรกจาเป็ นต้องติดตั้งเพิม่ เติม โดยมีฟังก์ชนั่ ให้ใช้งานดังนี้
1. ฟั ง ก์ ชั่ น ก าหนดการเชื่ อ มต่ อ ใช้ใ นการระบุ ก ารเชื่ อ มต่ อ โดยจะเชื่ อ มโยงกับ ไลบรารี่
OneWire.h รู ปแบบเป็ นดังนี้
DallasTemperature sensor_name(&onewire_name);
sensor_name: ชื่อของเซนเซอร์ ที่ต้ งั ขึ้นเพื่อเรี ยกใช้
onewire_name: ชื่อของอุปกรณ์ที่เชื่อมต่อทางพอร์ ตที่สื่อสารแบบ One wire
ตัวอย่างเช่ น DallasTemperature sensor(&ds);

หมายถึง ต่อไปในโปรแกรมจะใช้ชื่อ sensor ในการเรี ยกใช้งานที่ เชื่ อมต่อแบบ One
wire ที่อุปกรณ์ที่ชื่อว่า ds ที่ได้กาหนดจากไลบรารี่ OneWire.h
2. ฟังก์ชั่นเริ่มให้ ทางาน ใช้ในการกระตุน้ ให้เซนเซอร์ทางาน รู ปแบบเป็ นดังนี้

sensor_name.begin();
sensor_name: ชื่อของเซนเซอร์ ที่ต้ งั ชื่อไว้
ตัวอย่างเช่ น sensor.begin();
หมายถึง ให้ไอซี ตรวจวัดอุณภูมิที่ชื่อว่า sensor เริ่ มทางาน
3. ฟังก์ชั่นอ่ านค่ าอุณหภูมิทเี่ ป็ นเซลเซียส ใช้ในการอ่านค่าอุณหภูมิ รู ปแบบเป็ นดังนี้

sensor_name.getTempCByIndex(0)
ตัวอย่างเช่ น Serial.println(sensor.getTempCByIndex(0));
หมายถึง ให้พิมพ์อุณหภูมิที่อ่านได้จากไอซี ตรวจวัดอุณภูมิที่ชื่อว่า sensor
4. ฟังก์ชั่นอ่ านค่ าอุณหภูมิทเี่ ป็ นฟาเรนไฮต์ ใช้ในการอ่านค่าอุณหภูมิ รู ปแบบเป็ นดังนี้

sensor_name.getTempFByIndex(0)
ตัวอย่างเช่ น Serial.println(sensor.getTempFByIndex(0));
หมายถึง ให้พิมพ์อุณหภูมิที่อ่านได้จากไอซี ตรวจวัดอุณภูมิที่ชื่อว่า sensor
กรณี ใช้วงจรที่สร้างขึ้นเองจากไอซี ไมโครคอนโทรลเลอร์ AVR ที่ลงบูตโหลดเดอร์เป็ น Arduino

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC R4-R5
SW1 220 LED1-LED3
1 AVCC
RST 4
C1 D2
0.1uF 5
D3
R6
4.7k VCC
R2,R3
USB to UART (TTL Level) 1k 3 DS18B20
DTR 3 6
RXD D1(TXD) 2 DQ VCC
2 D4
TXD D0(RXD)
+5V GND
GND 1
3V3
R7
4.7k VCC
3 DS18B20
D5
11 2 DQ VCC
X1
16MHz 9 GND
XTAL1
1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
R1-R2 LED1-LED3
220
D2
D3
R3
4.7k VCC
3 DS18B20
D4 2 DQ VCC
GND
1
R4
4.7k VCC
3 DS18B20
D5 2 DQ VCC
GND
1
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D S1 8 D S1 8
B 20 B 20
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

ปัญหาการจาลองการทางานของไลบรารี่ DallasTemperature.h
ในใบงานที่ผา่ นมาการจาลองการทางานสามารถจาลองได้ปกติไม่มีขอ้ ผิดพลาดใด ๆ แต่สาหรับ
ใบงานนี้ มีการใช้ไลบรารี่ DallasTemperature.h เพื่ออ่านค่าอุ ณหภู มิจากไอซี DS18B20 จะไม่สามารถ
อ่านค่าได้แม้วา่ โค้ดนั้นสามารถทดลองในวงจรจริ งได้ก็ตาม ทั้งนี้เกิดจากเวอร์ ชนั่ ของโปรแกรม Arduino
IDE ซึ่งถ้าหากต้องการที่จะจาลองการทางานเพื่อดูผลการทางานจะต้องไปใช้เวอร์ ชนั่ 1.6.5
(a) เมื่อใช้ Arduino IDE เวอร์ ชนั่ ที่สูงกว่า 1.6.5 (b) เมื่อใช้ Arduino IDE V. 1.6.5
รู ปที่ 4.9-5 ผลการทดลองในโปรแกรมจาลองการทางานจาก Arduino IDE ต่างเวอร์ ชนั่
การทดลองที่ 1 เขี ยนโปรแกรมแสดงค่าอุณหภูมิที่วดั จากไอซี DS18B20 จานวน 1 ตัวโดยแสดงผลที่
START
อ่ านค่าจากไอซี


1 #include <OneWire.h>
2 #include <DallasTemperature.h>
3 OneWire ds(4); //sensor on pin D4
4 DallasTemperature sensor(&ds);
5 float temp; //variable keep temp value
6 void temp_read(); //prototype of function read temp
7 void setup(void)
8 {
10 Serial.println("Dallas Temperature IC Control Library Demo");
11 sensor.begin();
12 }
13 void loop(void)
14 {
15 temp_read();
16 Serial.print("Temperature is: ");
17 Serial.println(temp);
18 Serial.println("-----------Next read---------------");
19 delay(1000);
20 }
21 void temp_read() // Temperature read
22 {
23 sensor.requestTemperatures();
24 temp = sensor.getTempCByIndex(0); //Read Temp
25 }
- บรรทัดที่ 1,2 รวมไฟล์ไลบรารี่ OneWire.h และ DallasTemperature.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 3 ประกาศใช้งานไลบรารี่ OneWire พร้อมกาหนดชื่ออุปกรณ์และขาพอร์ ตที่เชื่ อมต่อ
- บรรทัดที่ 4 ประกาศใช้งานไลบรารี่ DallasTemperature พร้อมกาหนดชื่ออุปกรณ์และขาพอร์ ตที่
เชื่อมต่อ
- บรรทัดที่ 5 ประกาศตัวแปรเก็บอุณหภูมิที่สามารถเก็บทศนิยมได้
- บรรทัดที่ 6 ประกาศตัวแปรฟังก์ชนั่ รองสาหรับอ่านค่าอุณหภูมิจากไอซี DS18B20
- บรรทัดที่ 11 สั่งให้อุปกรณ์เริ่ มทางาน
- บรรทัดที่ 15 เรี ยกใช้งานฟังก์ชนั่ รองให้อ่านค่าอุณภูมิ
- บรรทัดที่ 17 แสดงผลอุณภูมิจากตัวแปรที่เก็บค่าทางจอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
- บรรทัดที่ 21-25 ฟังก์ชนั่ รองที่มีหน้าที่อ่านค่าอุณภูมิ
1. จาลองการทางานด้วยโปรแกรม Proteus (ใช้ Arduino IDE v. 1.6.5 ในการคอมไพล์)
3. ทดลองให้อุณหภูมิที่ตวั ไอซี เปลี่ยนแปลงแล้วสังเกตผล
การทดลองที่ 2 เขี ยนโปรแกรมแสดงค่าอุ ณหภู มิที่วดั จากไอซี DS18B20 จานวน 2 ตัวโดยแสดงผลที่

START

3 OneWire ds_1(4); //sensor 1 on pin D4
5 DallasTemperature sensor_1(&ds_1);
7 float temp_1; //variable keep temp value
9 void temp_read();
10 void setup(void)
11 {
13 Serial.println("Dallas Temperature IC Control Library Demo");
14 sensor_1.begin();
16 }
17 void loop(void)
18 {
19 temp_read();
20 Serial.print("Temperature for Device 1 is: ");
21 Serial.println(temp_1);
22 Serial.print("Temperature for Device 2 is: ");
23 Serial.println(temp_2);
24 Serial.println("-----------Next read---------------");
25 delay(1000);
26 }
27 void temp_read()
28 {
29 sensor_1.requestTemperatures();
31 //------------------------------------------
32 temp_1 = sensor_1.getTempCByIndex(0); //read temp from sensor_1
34 }
- บรรทัดที่ 1,2 รวมไฟล์ไลบรารี่ OneWire.h และ DallasTemperature.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 3 ประกาศใช้งานไลบรารี่ OneWire พร้ อมกาหนดชื่ ออุปกรณ์ ตวั ที่ 1 และขาพอร์ ตที่
- บรรทัดที่ 4 ประกาศใช้งานไลบรารี่ OneWire พร้ อมกาหนดชื่ ออุปกรณ์ ตวั ที่ 2 และขาพอร์ ตที่
- บรรทัดที่ 5 ประกาศใช้งานไลบรารี่ DallasTemperature พร้อมกาหนดชื่ ออุปกรณ์ตวั ที่ 1 และขา
พอร์ตที่เชื่อมต่อ
- บรรทัดที่ 6 ประกาศใช้งานไลบรารี่ DallasTemperature พร้อมกาหนดชื่ ออุปกรณ์ตวั ที่ 2 และขา
พอร์ตที่เชื่อมต่อ
- บรรทัดที่ 7,8 ประกาศตัวแปรเก็บอุณหภูมิที่อ่านได้จากอุปกรณ์ตวั ที่ 1 และ 2 ตามลาดับ
- บรรทัดที่ 9 ประกาศตัวแปรฟังก์ชนั่ รองสาหรับอ่านค่าอุณหภูมิจากไอซี DS18B20
- บรรทัดที่ 14,15 สั่งให้อุปกรณ์ตวั ที่ 1 และ 2 เริ่ มทางาน
- บรรทัดที่ 19 เรี ยกใช้งานฟังก์ชนั่ รองให้อ่านค่าอุณภูมิ
- บรรทั ด ที่ 21 แสดงผลอุ ณ ภู มิ จ ากตัว แปรที่ เ ก็ บ ค่ า อุ ณ หภู มิ จ ากไอซี ต ัว ที่ 1 โดยแสดงผลที่
- บรรทั ด ที่ 22 แสดงผลอุ ณ ภู มิ จ ากตัว แปรที่ เ ก็ บ ค่ า อุ ณ หภู มิ จ ากไอซี ต ัว ที่ 2 โดยแสดงผลที่
- บรรทัดที่ 21-25 ฟั งก์ชนั่ รองที่มีหน้าที่อ่านค่าอุณภูมิโดยค่าที่ อ่านได้เก็บลงในตัวแปรที่ใช้เก็บ
อุณหภูมิที่ประกาศไว้โดยเป็ นประเภทตัวแปรโกลบอล
3. ทดลองให้อุณหภูมิที่ตวั ไอซีเปลี่ยนแปลงแล้วสังเกตผล

1. เขียนโปรแกรมควบคุมการติดดับของ LED ทั้ง 2 ตัวจากอุณหภูมิที่วดั ได้จากไอซี DS18B20
โดยแสดงผลการทางานและอุณภูมิที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
ARDUINO
R1-R2 LED1-LED3
220
D2
D3
R3
4.7k VCC
3 DS18B20
D4 2 DQ VCC
GND
1
R4
4.7k VCC
3 DS18B20
D5 2 DQ VCC
GND
1
GND
รู ปที่ 4.9-6 วงจรที่ใช้ทดลอง

ใบงานที่ 4.10 การเขียนโปรแกรมวัดระยะด้วยโมดูลอัลตร้าโซนิค  139
การเขียนโปรแกรมวัดระยะด้ วยโมดูลอัลตร้ าโซนิค
เพื่อให้สามารถเขียนโปรแกรมวัดระยะด้วยโมดูลอัลตร้าโซนิคได้
1. บอกวิธีเขียนโปรแกรมวัดระยะด้วยโมดูลอัลตร้าโซนิคได้
4. โมดูลอัลตร้าโซนิค HC-SR04 1 ตัว
เสี ยงเป็ นคลื่นชนิดหนึ่งที่สามารถเดินทางผ่านอากาศได้ดงั นั้นถ้าใช้คุณสมบัติน้ ีมาสร้างเครื่ องวัด
ระยะทางโดยอาศัยการเดินทางของเสี ยงผ่านอากาศก็สามารถทาได้เช่นกัน เนื่ องจากความถี่เสี ยงจะมีช่วง
ของความถี่ช่วงหนึ่งที่มนุษย์สามารถได้ยินเสี ยงได้คืออยูใ่ นช่วง 20Hz-20kHz ดังนั้นหากใช้เสี ยงในช่วงนี้
ก็ จะเป็ นการรบกวนการได้ยินของมนุ ษ ย์ด้วย ดัง นั้นจึ ง ต้องใช้ค วามถี่ ที่ สู ง กว่า ความถี่ เสี ย งปกติ เพื่อ
หลี กเลี่ยงการได้ยินของมนุ ษย์ในปั จจุบนั ได้มีการใช้ความถี่ 40kHz เพื่อใช้ในการวัดระยะทางความถี่น้ ี
เป็ นความถี่ที่สูงกว่าเสี ยงที่มนุษย์ได้ยนิ จึงเรี ยกเสี ยงนี้วา่ “อัลตร้าโซนิค” โมดูลวัดระยะทางโดยใช้อลั ตร้า-
โซนิ คจะประกอบด้วยลาโพงที่ส่งคลื่ นเสี ยงและไมโครโฟนที่ทาหน้าที่เป็ นตัวรับเสี ยง แต่เนื่ องจากตัว
ลาโพงในโมดู ลมีขนาดเล็กเสี ยงที่ส่งออกจึงมีเสี ยงเบาทาให้ระยะของการวัดไม่ไกลนักซึ่ งจะมีระยะไม่
เกิน 5 เมตรและมีมุมที่ใช้งานแคบดังรู ป
รู ปที่ 4.7-1 รู ปร่ างของมุมกระจายคลื่นเสี ยงของโมดูลอัลตร้าโซนิค
โมดูลอัลตราโซนิคสาหรับวัดระยะทางถูก สร้างมีให้เลือกใช้หลายรุ่ นแต่ละรุ่ นมีขอ้ แตกต่างกัน

อย่างเดียวคือความแม่นยาของการวัดดังตาราง การเลือกใช้งานหากระดับความแม่นยาไม่สาคัญมากนัก
โมดูล HR-SC04 จึงเหมาะที่จะนามาทดลองใช้ในใบงานเนื่ องจากเป็ นโมดูลวัดระยะที่มีราคาถูกกว่ารุ่ น
อื่น ๆ
ตารางที่ 4.10-1
HR-SC04 HY-SRF05 US-100
1. Sensor angle < 15 degrees < 15 degrees < 15 degrees
2. Detection distance 2cm-450cm 2cm-450cm 2cm-450cm
3. precision ~3 mm ~2 mm ~1 mm
4. Working Voltage 5VDC 5VDC 5VDC
5. Static current < 2mA < 2mA < 2mA
การเขียนโค้ดโปรแกรมเพื่อวัดระยะทางด้วยโมดูลอัลต้าโซนิ คสามารถเขียนโดยไม่พึงไลบรารี่ ก็
ได้ หรื อถ้าหากต้องการใช้ไลบรารี่ เพื่อให้การเขียนโค้ดง่ายขึ้นสามารถดาวน์โหลดได้ที่
Ultrasonic.h https://github.com/JRodrigoTech/Ultrasonic-HC-SR04

1. ดาวน์โหลดไลบรารี่ ซ่ ึงเป็ นไฟล์ Zip ดังรู ป
รู ปที่ 4.10-2 การดาวน์โหลดไลบรารี่ ที่นามาใช้งาน
2. แต่เนื่ องจากการบีบอัดไฟล์ไลบรารี่ จดั โฟลเดอร์ ไม่ถูกต้องดังนั้นการเพิ่มไลบรารี่ เช่ นใบงานที่

ผ่านมาจึงไม่สามารถใช้งานได้ วิธีการติดตั้งจึงต้องจัดการเองทั้งหมดเริ่ มจากแตกไฟล์ที่ดาวน์
โหลด ดังรู ป
รู ปที่ 4.10-3 แตกไฟล์ที่ดาวน์โหลดมาในโฟลเดอร์ปัจจุบนั
3. ทาการดับเบิลคลิกเข้าไปในโฟลเดอร์ที่แตกมาได้จากข้อ 2 คัดลอกเฉพาะโฟลเดอร์ Ultrasonic

(คลิกขวาที่โฟลเดอร์ เลือก copy)
รู ปที่ 4.10-4 คัดลอกโฟลเดอร์ Ultrasonic

4. นาไปวางในโฟลเดอร์ ที่เก็บไลบรารี่ ของโปรแกรม Arduino IDE ซึ่ งจะอยูท่ ี่

C:\Users\......\Documents\Arduino\libraries
(คลิกขวาบริ เวณว่าง ๆ ภายในโฟลเดอร์ แล้วเลือก paste)
รู ปที่ 4.10-5 วางโฟลเดอร์ ที่คดั ลอกลงในโฟลเดอร์ไลบรารี่ ของ Arduino IDE

pinMode(pin, mode);
value: HIGH or LOW
delay(ms);
4. ฟังก์ชั่นหน่ วงเวลาเป็ นไมโครวินาที เนื่องจากฟั งก์ชนั่ หน่วงเวลาปกติเวลาต่าสุ ดที่ทาได้คือ 1

มิลลิวนิ าที ดังนั้นหากต้องการหน่วงเวลาที่ต่ากว่าจึ่งต้องใช้ฟังชัน่ นี้ซ่ ึ งสามารถหน่วงเวลาได้
ในระดับไมโครวินาที รู ปฟังชัน่ เป็ นดังนี้
delayMicroseconds(us);
us: ตัวเลขที่หยุดค้างของเวลาหน่วยไมโครวินาที (unsigned int)

8. ฟังก์ชั่นวัดความกว้างของพัลซ์ โดยค่าที่วดั ได้เป็ นเวลาหน่วยเป็ นไมโครวินาที (uS) ผูใ้ ช้งาน
สามารถระบุลอจิกของสัญญาณที่ใช้ในการวัดได้ เช่ นเมื่อกาหนดลอจิกที่ใช้ตรวจจับเป็ น
HIGH ฟั งก์ชั่นจะเริ่ มนับเวลาเมื่ อขาสัญญาณที่ ตรวจจับ เป็ นลอจิ ก HIGH โดยนับเวลาไป
จนกว่าสัญญาณจะเป็ นเป็ น LOW เวลาที่ได้เป็ นตัวเลขที่มีหน่วยเป็ นไมโครวินาที รู ปฟั งชัน่
เป็ นดังนี้
pulseIn(pin, value);
pin: ขาพอร์ตที่ใช้ในการตรวจจับสัญญาณพัลซ์
value: ค่าลอจิ กที่ ใช้กาหนดเพื่ อใช้ในนับเวลาโดยฟั ง ก์ชั่นจะหยุดนับ เมื่ อค่ า
ลอจิกเป็ นตรงข้าม
duration = pulseIn(12, HIGH);
หมายถึ ง วัด ความกว้า งของพัล ซ์ โ ดยการจับ เวลา เมื่ อ ขา D12 เป็ นลอจิ ก HIGH
จนกระทั่ง ขา D12 มี ก ารเปลี่ ย นลอจิ ก เป็ น LOW โดยค่ า ที่ ไ ด้เ ป็ นตัว เลขหน่ ว ยเป็ น
ไมโครวินาทีแล้วเอาไปเก็บไว้ในตัวแปร duration
ฟังก์ชั่นใช้ งานของไลบรารี่ Ultrasonic.h

การอ่านค่าจากโมดูล Ultrasonic จาเป็ นต้องใช้ไลบรารี่ ช่วยงาน ซึ่ งไลบรารี่ ไม่ได้ถูกเพิม่ เข้ามาใน
ตัวโปรแกรม Arduino IDE ตั้งแต่แรกจาเป็ นต้องติดตั้งเพิ่มเติม โดยมีฟังก์ชนั่ ให้ใช้งานดังนี้
1. ฟังก์ ชั่นกาหนดขาเชื่ อมต่ อ ใช้ในการระบุขาที่ใช้เชื่ อมต่อให้ตวั โปรแกรมรับรู ้ รู ปแบบเป็ น

ดังนี้
Ultrasonic ultrasonic(Trig PIN,Echo PIN);
Trig PIN: ตัวเลขระบุขาพอร์ ตที่ใช้เชื่อมต่อกับขา Trig ของโมดูล
Echo PIN: ตัวเลขระบุขาพอร์ตที่ใช้เชื่อมต่อกับขา Echo ของโมดูล
Ultrasonic ultrasonic(9,8);
หมายถึง ต่อไปในโปรแกรมจะใช้ชื่อ ultrasonic ในการเรี ยกใช้งานโมดู ล โดยมีการ
เชื่อมต่อขาพอร์ ต D9 เข้าที่ขา Trig และขาพอร์ต D8 เข้าที่ขา Echo ของโมดูล
2. ฟังก์ ชั่นอ่ านค่ าระยะทาง ใช้อ่านค่าระยะทางจากตัวโมดูลโดยสามารถระบุหน่ วยที่ตอ้ งการ

วัดได้ 2 แบบคือ เซนติเมตร (CM) และหน่วยที่เป็ นนิ้ว (IN) รู ปแบบเป็ นดังนี้
.Ranging(Unit);
Unit: หน่วยที่ตอ้ งการวัด CM ,IN
Serial.print(ultrasonic.Ranging(CM));
หมายถึง แสดงผลระยะที่วดั ได้หน่วยเป็ นเซนติเมตรทางพอร์ ตอนุกรม
การเปลีย่ นค่ า time out เพื่อปรับระยะการวัด (สาหรับเมื่อใช้ งานไลบรารี่)

ค่ า ปกติ ข องไลบรารี่ ถู ก ก าหนดมาให้วดั ได้ป ระมาณ 51 cm ซึ่ ง มี ค่ า Default TimeOut เท่ า กับ
3000 µs = 51cm เมื่อใช้ฟังก์ชนั่ ที่มีการป้ อนค่า 2 ค่าที่เป็ นขาเชื่อมต่อดังนี้
Ultrasonic ultrasonic(Trig PIN,Echo PIN);
Trig PIN : ขา Trig ของโมดูลอัลตร้าโซนิค
Echo PIN : ขา Echo ของโมดูลอัลตร้าโซนิค
ผูใ้ ช้สามารถเปลี่ยนค่าระยะการวัดได้ โดยการกาหนดค่า TimeOut เข้าในฟังก์ชนั่ ตัวอย่างเช่น

Ultrasonic ultrasonic(Trig PIN,Echo PIN,MaxTimeout);
Trig PIN : ขา Trig ของโมดูลอัลตร้าโซนิค
Echo PIN : ขา Echo ของโมดูลอัลตร้าโซนิค
Max.TimeOut: ค่าเวลา Time out สู งสุ ดสาหรับวัดระยะที่ตอ้ งการวัด (µs)
วิธีการคานวณค่ า TimeOut เพื่อให้ ได้ ระยะการวัดทีต่ ้ องการ

ระยะการสู งสุ ดที่ตอ้ งการวัด สู ตร ตัวอย่างการคานวณ
หน่วยเป็ นเซนติเมตร TimeOut = Max.Distance(cm) * 58 50 cm * 58 = 2900 µs
หน่วยเป็ นนิ้ว TimeOut = Max.Distance(inc) * 148 25 inc * 148 = 3700 µs
ค่า Time out จะต้องไม่เกินค่าระยะทางที่โมดูลอัลตร้าโซนิคทางานได้นนั่ คือ 450 cm

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
VCC
R2,R3 1
USB to UART (TTL Level) 1k VCC
HC-SR04
DTR 3 15 2
RXD D1(TXD) D9 Trig
2 14 3
TXD D0(RXD) D8
+5V Echo
GND 4
3V3 GND
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
GND
Echo
Trig
VCC
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
HC-SR04
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1


เนื่ องจากโปรแกรมจาลองการทางานไม่มีโมเดลอัลตราโซนิ ครุ่ น HR-SC04 ให้จาลองจึงต้องใช้
โมเดลจากไลบรารี่ ที่เพิ่มเข้ามา ซึ่ งไลบรารี่ ดงั กล่าวภายในเป็ นซี พียูที่เขียนโค้ดให้ส่งค่าเลียนแบบอัลตร้า
โซนิ คซึ่ งสามารถปรับค่าได้โดยอาศัยแรงดันควบคุ มผ่านการปรับโพเทนธิ โอมิ เตอร์ ดังนั้นเมื่อใช้งาน
จะต้องโหลดไฟล์โปรแกรมควบคุมเข้าโมเดลเช่ นเดี ยวกับการจาลองไมโครคอนโทรลเลอร์ ไฟล์ที่ตอ้ ง
โหลดเข้าโมเดลเป็ นไฟล์ภาษาเครื่ องที่มาพร้อมกับไลบรารี่ ดงั รู ป
รู ปที่ 4.10-10 ไฟล์ภาษาเครื่ องสาหรับโมเดลอัลตร้าโซนิค

การทดลองที่ 1 เขียนโปรแกรมวัดระยะโดยการใช้โมดู ลอัลตร้ าโซนิ คแบบไม่ใช้ไลบรารี่ แสดงผลที่
START
ส่ งพัลซ์ 10uS ที่ขา Trig
จับเวลาที่ขา Echo
คานวณเป็ นระยะทาง
แสดงผล

1 #define TRIGGER_PIN 9 // digital pin D9
2 #define ECHO_PIN 8 // digital pin D8
3 void setup()
4 {
5 Serial.begin (9600);
6 pinMode(TRIGGER_PIN, OUTPUT);
7 pinMode(ECHO_PIN, INPUT);
8 }
9 void loop()
10 {
11 double duration, distance;
12 digitalWrite(TRIGGER_PIN, LOW); // Get Start
13 delayMicroseconds(2); // stable the line
14 digitalWrite(TRIGGER_PIN, HIGH); // sending 10 us pulse
15 delayMicroseconds(10); // delay
16 digitalWrite(TRIGGER_PIN, LOW); // waiting to receive signals
17 duration = pulseIn(ECHO_PIN, HIGH); // calculating time
18 distance = (duration/2) / 29.1; // single path
19 Serial.print(distance);
20 Serial.println(" cm");
21 delay(500);
22 }
- บรรทัดที่ 1,2 กาหนดชื่ อ TRIGGER_PIN ให้แทน 9 และ ECHO_PIN ให้แทน 8 (ขา Triger ต่อ
เข้าที่ขา D9 และขา Echo ของโมดูลอัลตร้าโซนิคต่อเข้าที่ขา D8 ของ Arduino)
- บรรทัดที่ 6,7 กาหนดโหมดการทางานของขาที่ใช้เชื่อมต่อกับโมดูลอัลตราโซนิค
- บรรทัดที่ 11 ประกาศตัวแปรที่ใช้ประกอบการคานวณระยังทาง
- บรรทัดที่ 12-16 ส่ งสัญญาณพัลส์ไปกระตุน้ การทางานของโมดูลอัลตร้าโซนิค
- บรรทัดที่ 17 เก็บค่าเวลาที่มีสัญญาณสะท้อนกลับ
- บรรทัดที่ 18 คานวณระยะทางที่วดั ได้
- บรรทัดที่ 19 แสดงค่าระยะทางที่วดั ได้ ที่จอคอมพิวเตอร์ ผา่ นทางพอร์ ตอนุกรม
3. ทดลองวัดระยะวัดถุในตาแหน่งที่ต่าง ๆ กันสังเกตค่าที่อ่านได้
การทดลองที่ 2 เขี ย นโปรแกรมวัด ระยะโดยการใช้โ มดู ล อัล ตร้ า โซนิ ค แบบใช้ไ ลบรารี่ แสดงผลที่
START
อ่ านค่าระยะทาง
แสดงผล

1 #include <Ultrasonic.h>
2 Ultrasonic ultrasonic(9,8); // (Trig PIN,Echo PIN)
3 void setup() {
5 }
6 void loop()
7 {
8 Serial.print(ultrasonic.Ranging(CM)); // CM or INC
9 Serial.println(" cm" );
10 delay(100);
11 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ Ultrasonic.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 ประกาศใช้งานไลบรารี่ พร้ อมระบุ ขาพอร์ ตที่ใช้เชื่ อมต่อกับโมดู ลและกาหนดชื่ อ
เรี ยกโมดูลตัวอย่างนี้กาหนดชื่อเรี ยกเป็ น ultrasonic
- บรรทัดที่ 8 เรี ยกใช้งานไลบรารี่ พร้อมแสดงค่าที่วดั ได้ที่จอคอมพิวเตอร์ ผา่ นพอร์ ตอนุกรม
3. ทดลองวัดระยะวัดถุในตาแหน่งที่ต่าง ๆ กันสังเกตค่าที่อ่านได้
4. เปรี ยบเทียบความแตกต่างของการการวัดระหว่างโค้ดที่ใช้กบั ไม่ใช้ไลบรารี่

1. เขียนโปรแกรมแจ้งเตือนการเข้าใกล้ (เช่นเดียวกับเซนเซอร์ ถอยหลังของรถยนต์) แสดงผลที่
LED จานวน 4 ตัวโดยมีเงื่อนไขการแสดงผลดังนี้
ระยะตรวจจับ การติดดับของ LED
s  1.5m
1.0m  s  1.5m
0.5m  s  1.0m
0s  0.5m
วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
R1-R4
220 LED1-LED4
D5
D4
D3
D2
GND
รู ปที่ 4.10-11 วงจรที่ใช้บอร์ ด Arduino ในการทดลอง

ใบงานที่ 4.11 การเขียนโปรแกรมควมคุมดีซีมอเตอร์  151
การเขียนโปรแกรมควมคุมดีซีมอเตอร์
เพื่อให้สามารถเขียนโปรแกรมควมคุมดีซีมอเตอร์ ได้
1. บอกวิธีเขียนโปรแกรมควมคุมดีซีมอเตอร์ ได้
2.1 ไอซี L298D 1 ตัว 2.4 Potentiometer 10k 1 ตัว
2.2 ไดโอด 1N4001 1 ตัว 2.5 มอเตอร์ไฟตรง 6V 1 ตัว
2.3 ตัวเก็บประจุ 100 uF 1 ตัว
มอเตอร์ ไฟฟ้ ากระแสตรง (DC motor) เป็ นเครื่ องกลไฟฟ้ าชนิ ดหนึ่ งที่มีหน้าที่เปลี่ยนพลังงาน
งานไฟฟ้าไปเป็ นพลังงานกล เมื่อได้รับการป้ อนพลังงานไฟฟ้าที่เป็ นไฟฟ้ากระแสตรงจะทาให้แกนของ
มอเตอร์ หมุน แต่เนื่ องจากการทางานของมอเตอร์ ไฟฟ้ ากระแสตรงต้องการกระแสไฟฟ้ าในปริ มาณสู ง
กว่า ความสามารถที่ ไ มโครคอนโทรลเลอร์ จะจ่ า ยโดยตรงได้ จึ งจาเป็ นที่ จะต้องมี วงจรขับ มอเตอร์
โดยเฉพาะเพื่อทาหน้าที่ขบั มอเตอร์ให้ทางานได้ตามต้องการ
รู ปที่ 4.11-1 ตัวอย่างมอเตอร์ ไฟฟ้ากระแสตรงขนาดเล็กแบบปกติ
รู ปที่ 4.11-2 ตัวอย่างมอเตอร์ ไฟฟ้ากระแสตรงขนาดเล็กแบบที่มีชุดเฟื องทดรอบ
มอเตอร์ ไฟฟ้ ากระแสตรงขนาดเล็ก จะถู ก นามาใช้ใ นโครงงานที่ มีกลไกการเคลื่ อนไหวมี ค่ า

แรงดันไฟฟ้าในการทางานในช่วง 1.5 โวลต์ถึง 12 โวลต์
การควบคุมการทางานของมอเตอร์ ไฟฟ้ ากระแสตรงนั้นสามารถทาได้ง่ายเพียงป้ อนไฟเข้าที่ข้ วั

มอเตอร์ เมื่อต้องการให้มอเตอร์ หมุนและเมื่อต้องการให้มอเตอร์ หยุดหมุนก็เพียงหยุดการป้ อนไฟฟ้า หรื อ
ถ้าหากต้องการให้มอเตอร์ หมุ นกลับทิ ศทางก็สามารถทาได้โดยการสลับขั้วไฟฟ้ าที่ จ่ายให้กบั มอเตอร์
เพียงเท่านี้ มอเตอร์ ไฟฟ้ ากระแสตรงก็จะสามารถหมุนกลับทิศทางได้ในทันที สาหรับวงจรขับมอเตอร์ ที่
สามารถควบคุ ม ทิ ศ ทางการหมุ น ได้ ป ระกอบด้ว ยอุ ป กรณ์ ที่ ถู ก จัด วางที่ มี ล ัก ษณะคล้า ยตัว H ใน
ภาษาอังกฤษจึงเรี ยกวงจรขับมอเตอร์ ไฟฟ้ ากระแสตรงในลักษณะนี้ ว่าวงจรขับแบบ H-Bridge ลักษณะ
ของวงจรเป็ นดังรู ปที่ 4.11-3
S1 S3
Vs M
S2 S4
รู ปที่ 4.11-3 วงจรขับแบบ H-Bridge
จากรู ปที่ 4.11-3 เป็ นวงจรขับแบบ H-Bridge ที่ใช้สวิตช์ ในสภาวะแรกเริ่ มที่สวิตช์ทุกตัวยังไม่

ทางานมอเตอร์ จะไม่ได้รับกระแสไฟฟ้าทาให้มอเตอร์ ไม่หมุน เมื่อทาการควบคุมให้สวิตซ์ทางานโดยให้
S1 และ S4 ทางาน มอเตอร์ จะหมุนตามเข็มนาฬิกา (CW: Clock wise) หากต้องการให้มอเตอร์ หมุนกลับ
ทิ ศ ทางโดยให้ม อเตอร์ หมุนทวนเข็มนาฬิ กา (CCW: Counter clock wise) ก็ เพี ย งสลับการท างานของ
สวิตช์โดยให้ S1, S4 ไม่ทางานและให้สวิตช์ S2, S3 ทางานแทน การควบคุมดังกล่าวจะมีลกั ษณะดังรู ปที่
14.11-4
S1 S3 S1 S3
Vs M Vs M
S2 S4 S2 S4
(a) (b)
รู ปที่ 4.11-4 การควบคุมการหมุนของมอเตอร์ดว้ ยวงจรขับแบบ H-Bridge
ตารางที่ 4.11-1 การควบคุมมอเตอร์ดว้ ยวงจรขับแบบ H-Bridge แบบใช้สวิตช์

สถานะของสวิตช์
สถานะของมอเตอร์ไฟฟ้ากระแสตรง
S1 S2 S3 S4
OFF OFF OFF OFF ไม่หมุน
ON OFF OFF ON หมุนตามเข็มนาฬิกา (CW)
OFF ON ON OFF หมุนทวนเข็มนาฬิกา (CCW)
วงจรขับมอเตอร์ ที่เป็ นลักษณะ H-Bridge สามารถเปลี่ยนจากการใช้สวิตช์มาเป็ นรี เลย์ โดยใช้

รี เลย์ที่เป็ นชนิ ด SPDT (Single pole double throw) ดังรู ปที่ 4.11-5 และการควบคุมทิศทางการหมุนเป็ น
ดังรู ป 4.11-6
+Vs
RY1 M RY2
รู ปที่ 4.11-5 วงจรขับมอเตอร์ แบบ H-Bridge ที่ใช้รีเลย์

+Vs +Vs
S1 S2
V1 RY1 M RY2 RY1 M RY2 V2
(a) (b)
รู ปที่ 4.11-6 การควบคุมการหมุนของมอเตอร์ดว้ ยวงจรขับแบบ H-Bridge ที่ใช้รีเลย์
การใช้ง านจริ ง มี ไ อซี ที่ ถู ก ออกแบบมาเพื่ อ การนี้ โดยเฉพาะมี คุ ณ สมบัติ เ ป็ นวงจรขับ แบบ
H-Bridge ในกรณี ที่ใช้กบั มอเตอร์ ไฟฟ้ ากระแสตรงขนาดเล็กที่ใช้กระแสไม่เกิ น 600 มิลลิแอมป์ จะใช้
ไอซีเบอร์ L293D แต่หากมอเตอร์ ไฟฟ้ ากระแสตรงใช้กระแสสู งเกินค่าดังกล่าวแต่ไม่เกิน 4 แอมป์ จะต้อง
ใช้ไอซี เบอร์ L298 ในใบงานนี้ ใช้มอเตอร์ ไฟฟ้ ากระแสตรงขนาดเล็กซึ่ งจะใช้ไอซี เบอร์ L293D ในการ
ทดลองโดยโครงสร้างของไอซีเป็ นดังรู ปที่ 4.11-7
EN3,4
GND
GND
VCC
4A
3A
4Y
3Y
16 15 14 13 12 11 10 9
1 2 3 4 5 6 7 8
GND
GND
VS
EN1,2
1A
1Y
2Y
2A
รู ปที่ 4.11-7 โครงสร้างไอซีขบั มอเตอร์กระแสตรงขนาดเล็กเบอร์ L293D

pinMode(pin, mode)
3. ฟั งก์ ชั่ นหน่ ว งเวลา หรื อฟั ง ก์ชั่นหยุดค้า ง การใช้ง านสามารถก าหนดตัว เลขของเวลาที่
delay(ms)

Serial.begin(speed)
7. ฟั งก์ ชั่ น อ่ า นสั ญญาณแอนาลอก เป็ นฟั ง ก์ชั่นอ่ า นสั ญ ญาณแอนาลอกที่ ป รากฏอยู่ที่ ข าที่
ต้องการอ่านนั้น ๆ ค่าที่อ่านได้จะอยูใ่ นช่วง 0-1023 สาหรับแรงดันของสัญญาณแอนาลอกที่
0-5V ดังนั้นต้องใช้ตวั แปรที่เป็ น int สาหรับเก็บค่าที่อ่านได้
analogRead(pin)
8. ฟังก์ชั่นให้ ขาพอร์ ตส่ งสั ญญาณ PWM เป็ นฟังก์ชนั่ ที่ให้ขาพอร์ ตดิจิทลั ขา 3, 5, 6, 9, 10 และ
11 (ซึ่ งเป็ นขาที่ส่งสัญญาณ PWM ได้) ส่ งสัญญาณ PWM ออกตามค่าดิ วติ้ไซเคิลที่กาหนด
ด้วยความถี่ 490 Hz
analogWrite(pin, value)
pin: ขาพอร์ตดิจิทลั ที่ตอ้ งการส่ งสัญญาณ PWM
value: ค่าดิวติ้ไซเคิลที่อยูร่ ะหว่าง 0 ถึง 255

value: ตัวแปรที่ตอ้ งการอ่านค่านามาเปลี่ยนช่วงตัวเลข
fromLow: ตัวเลขสเกลล่างสุ ดของค่าจากตัวแปร
fromHigh: ตัวเลขสเกลสู งสุ ดของค่าจากตัวแปร
toLow: ตัวเลขสเกลล่างสุ ดของค่าที่ตอ้ งการเปลี่ยนไป
toHigh: ตัวเลขสเกลสู งสุ ดของค่าที่ตอ้ งการเปลี่ยนไป

VCC

1N5819
R1 VCC D2
10k 7,20 ATMEGA328 1N4001 C4
VCC 100uF
SW1
1 AVCC
RST 16 8
C1
VCC
VS
0.1uF M1
(PWM)D11 17 1 EN1,2 1Y 3 M
D12 18 2 1A 2Y 6
D13 19 7 2A
R2,R3 M2
USB to UART (TTL Level) 1k (PWM)D10 16 9 EN3,4
3
D9 15 10 3A 3Y 11
DTR
RXD D1(TXD) M
2
TXD D0(RXD) D8 14 15 4A
4Y 14
+5V
GND
GND
GND
GND
GND
3V3
4 5 12 13 L293D
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC D1
1N4001 C1
ARDUINO 100uF
16 8
VCC
VS
M1
(PWM)D11 1 EN1,2 1Y 3 M
D12 2 1A
7 2Y 6
D13 2A
9 EN3,4 M2
(PWM)D10
D9 10 3A 3Y 11 M
D8 15 4A
4Y 14
GND
GND
GND
GND
GND
4 5 12 13 L293D

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
ULN2803A
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมควบคุมการทางานของดี ซีมอเตอร์ โดยควบคุ มทิศทางการหมุนให้มีท้ งั
หมุนตามเข็มนาฬิกา (CW) ทวนเข็มนาฬิกา (CCW) และหยุดหมุน การกลับทิศทางการหมุนจะต้องมีการ
สัง่ ให้หยุดหมุนก่อนช่วงเวลาหนึ่งเพื่อไม่ให้เกิดกระแสสู งกว่าปกติที่เกิดจากการต้านทิศทางการหมุน
START
มอเตอร์ 1 และ 2 หมุน (CW)
มอเตอร์ 1 และ 2 หยุดหมุน
มอเตอร์ 1 และ 2 หมุน (CCW)
มอเตอร์ 1แสดงผล
และ 2 หยุดหมุน

1 #define EN1 11
2 #define EN2 10
3 #define IN1 12
4 #define IN2 13
5 #define IN3 9
6 #define IN4 8
7 void AllStop(void);
8 void setup()
9 {
10 pinMode(EN1,OUTPUT);pinMode(EN2,OUTPUT);
11 pinMode(IN1,OUTPUT);pinMode(IN2,OUTPUT);
13 digitalWrite(EN1,HIGH);digitalWrite(EN2,HIGH);
14 AllStop();
15 }
16 void loop()
17 {
18 digitalWrite(IN1,LOW);digitalWrite(IN2,HIGH);delay(3000);
20 AllStop();
21 digitalWrite(IN1,HIGH);digitalWrite(IN2,LOW);delay(3000);
23 AllStop();
24 }
25 void AllStop(void)
26 {
27 digitalWrite(IN1,LOW);digitalWrite(IN2,LOW);
29 delay(250);
30 }
- บรรทัดที่ 1,2 กาหนดชื่อ EN1, EN2 ให้แทน 11, 10 (เป็ นขา Enable ของมอเตอร์ตวั ที่ 1 และ 2 ที่
ต่ออยูก่ บั ขา D11, D10 ของ Arduino)
- บรรทัดที่ 3,4 กาหนดชื่ อ IN1, IN2 ให้แทน 12, 13 (เป็ นขาควบคุมการหมุนของมอเตอร์ ตวั ที่ 1
- บรรทัดที่ 5,6 กาหนดชื่ อ IN3, IN4 ให้แทน 9, 8 (เป็ นขาควบคุมการหมุนของมอเตอร์ ตวั ที่ 2 ต่อ
อยูก่ บั ขา D12, D13 ของ Arduino)
- บรรทัดที่ 7 ประกาศรู ปแบบฟังก์ชนั่ รองที่ใช้หยุดการหมุนของมอเตอร์ ท้ งั 2 ตัว
- บรรทัดที่ 13 สั่งให้ไอซี L293D พร้อมการทางานโดยการกระตุน้ ที่ขา Enable
- บรรทัดที่ 14 เรี ยกใช้ฟังก์ชนั่ รองหยุดการหมุนของมอเตอร์
- บรรทัดที่ 18 สั่งให้มอเตอร์ ตวั ที่ 1 หมุนตามเข็มเป็ นเวลา 3 วินาที
- บรรทัดที่ 19 สั่งให้มอเตอร์ ตวั ที่ 2 หมุนตามเข็มเป็ นเวลา 2 วินาที
- บรรทัดที่ 21 สั่งให้มอเตอร์ ตวั ที่ 1 หมุนทวนเป็ นเวลา 3 วินาที
- บรรทัดที่ 22 สั่งให้มอเตอร์ ตวั ที่ 2 หมุนทวนเข็มเป็ นเวลา 2 วินาที
- บรรทัดที่ 25-30 ฟังก์ชนั่ รองที่สั่งงานให้หยุดการหมุนของมอเตอร์
3. ทดลองแก้โปรแกรมให้มอเตอร์ทางานในรู ปแบบอื่น ๆ แล้วสังเกตผล
การทดลองที่ 2 เขียนโปรแกรมควบคุมการหมุนของมอเตอร์ ที่มีการหมุนทั้งทิศทางตามเข็มและทวนเข็ม

นาฬิกาโดยสามารถปรับความเร็ วของการหมุนด้วย PWM ได้ โดยใช้โพเทนธิ โอมิเตอร์ ต่อเข้าพอร์ ตรับ
สัญญาณแอนาลอกเป็ นตัวปรับความเร็ วในการหมุนของมอเตอร์ดงั รู ป
VCC D1
1N4001 C1
ARDUINO 100uF
16 8
VCC
VS
M1
VCC (PWM)D11 1 EN1,2 1Y 3 M
D12 2 1A
7 2Y 6
D13 2A
A0 9 EN3,4 M2
(PWM)D10
10k D9 10 3A 3Y 11 M
D8 15 4A
4Y 14
GND
GND
GND
GND
GND
4 5 12 13 L293D

START
กาหนดค่าเริ ่มต้ นต่ า ง A

B
ครบ 100 รอบ? ครบ 100 รอบ?
จริ ง จริ ง
เท็จ เท็จ
อ่ านค่าจาก POT แล้ วส่ ง PWM อ่ านค่าจาก POT แล้ วส่ ง PWM
มอเตอร์ 1 และ 2 หมุน (CW) มอเตอร์ 1 และ 2 หมุน (CCW)
มอเตอร์ 1 และ 2 หยุดหมุน มอเตอร์ 1 และ 2 หยุดหมุน
A B
1 #define EN1 11
2 #define EN2 10
3 #define IN1 12
4 #define IN2 13
5 #define IN3 9
6 #define IN4 8
7 #define POT A0
8 void AllStop(void);
9 void setup()
10 {
11 pinMode(EN1,OUTPUT);pinMode(EN2,OUTPUT);
14 AllStop();
15 }
16 void loop()
17 {
18 int PWM;
19 for(int i=0;i<100;i++)
20 {
21 PWM=analogRead(POT);
22 PWM=map(PWM,0,1023,50,255);
23 analogWrite(EN1,PWM);analogWrite(EN2,PWM);
26 }
27 AllStop();
28 for(int i=0;i<100;i++)
29 {
30 PWM=analogRead(POT);
31 PWM=map(PWM,0,1023,50,255);
32 analogWrite(EN1,PWM);analogWrite(EN2,PWM);
35 }
36 AllStop();
37 }
38 void AllStop(void)
39 {
42 delay(250);
43 }
- บรรทัดที่ 1,2 กาหนดชื่อ EN1, EN2 ให้แทน 11, 10 (เป็ นขา Enable ของมอเตอร์ ตวั ที่ 1 และ 2 ที่
- บรรทัดที่ 3,4 กาหนดชื่ อ IN1, IN2 ให้แทน 12, 13 (เป็ นขาควบคุมการหมุนของมอเตอร์ ตวั ที่ 1
- บรรทัดที่ 5,6 กาหนดชื่ อ IN3, IN4 ให้แทน 9, 8 (เป็ นขาควบคุมการหมุนของมอเตอร์ ตวั ที่ 2 ต่อ
อยูก่ บั ขา D12, D13 ของ Arduino)
- บรรทัดที่ 7 กาหนดชื่อ POT ให้แทน A0 (เป็ นขาโพเทนธิ โอมิเตอร์ ต่ออยูก่ บั ขา A0 ของ Arduino)
- บรรทัดที่ 8 ประกาศรู ปแบบฟังก์ชนั่ รองที่ใช้หยุดการหมุนของมอเตอร์ ท้ งั 2 ตัว
- บรรทัดที่ 19-26 วนทาซ้ า 100 รอบ
- บรรทัดที่ 21-22 อ่านค่าจาก POT มาปรับค่าให้อยูใ่ นย่านที่จะส่ งค่า PWM ได้
- บรรทัดที่ 23 ส่ งสัญญาณ PWM เข้าที่ขา Enable ของไอซี L293D เพื่อให้สามารถปรับความเร็ ว
ในการหมุนได้
- บรรทัดที่ 24 สั่งให้มอเตอร์ ตวั ที่ 1 หมุนตามเข็มเป็ นเวลา 30 มิลลิวนิ าที
- บรรทัดที่ 25 สั่งให้มอเตอร์ ตวั ที่ 2 หมุนตามเข็มเป็ นเวลา 20 มิลลิวนิ าที
- บรรทัดที่ 28-37 มีข้ นั ตอนเดียวกันกับบรรทัดที่ 19-27 เพียงแต่สั่งให้มอเตอร์ หมุนทวนเข็ม
- บรรทัดที่ 38-43 ฟังก์ชนั่ รองที่สงั่ งานให้หยุดการหมุนของมอเตอร์
3. ทดลองแก้โปรแกรมให้มอเตอร์หมุนในรู ปแบบอื่น ๆ แล้วสังเกตผล

1. เขียนโปรแกรมควบคุมการหมุนโดยให้สามารถปรับความเร็ วของการหมุนของมอเตอร์ ใน
แต่ละตัวได้อย่างอิสระด้วยโพเทนธิโอมิเตอร์ 2 ตัว โดยโพเทนธิ โอมิเตอร์ ตวั ที่ 1 ให้ควบคุม
ความเร็ วของมอเตอร์ ตวั ที่ 1 และโพเทนธิ โอมิเตอร์ ตวั ที่ 2 ให้ควบคุมความเร็ วของมอเตอร์
ตัวที่ 2 วงจรที่ใช้ทดลองเป็ นดังรู ป
VCC D1
VCC 1N4001 C1
ARDUINO 100uF
16 8
A0
VCC
VS
M1
10k
(PWM)D11 1 EN1,2 1Y 3 M
D12 2 1A
7 2Y 6
D13 2A
9 EN3,4 M2
VCC (PWM)D10
D9 10 3A 3Y 11 M
D8 15 4A
4Y 14
GND
GND
GND
GND
A1
10k
GND
4 5 12 13 L293D

ใบงานที่ 4.12 การเขียนโปรแกรมควมคุมสเต็ปเปอร์มอเตอร์  163
การเขียนโปรแกรมควมคุมสเต็ปเปอร์ มอเตอร์
เพื่อให้สามารถเขียนโปรแกรมควมคุมสเต็ปเปอร์มอเตอร์ ได้
1. บอกวิธีเขียนโปรแกรมควมคุมสเต็ปเปอร์มอเตอร์ ได้
2.1 ไอซี ULN2803 1 ตัว
2.2 สเต็ปเปอร์มอเตอร์ 1 ตัว
สเต็ปเปอร์ มอเตอร์ หรื อที่บางคนเรี ยกว่าสเต็ปปิ้ งมอเตอร์ เป็ นมอเตอร์ ที่ทางานโดยอาศัยพลังงาน
จากไฟฟ้ ากระแสตรงเช่นเดียวกับมอเตอร์ กระแสตรง แต่มีความความแตกต่างจากมอเตอร์ กระแสตรงที่
เมื่ อ ป้ อ นไฟให้ ก ับ สเต็ป เปอร์ ม อเตอร์ จ ะขยับ เพี ย งเล็ ก น้อ ยเพื่ อ เข้า สเต็ป ในขณะที่ ม อเตอร์ ไฟฟ้ า
กระแสตรงทัว่ ไปจะหมุนตราบที่ยงั มีพลังงานจ่ายให้แก่ตวั มัน ทั้งนี้เป็ นเพราะโครงสร้างของสเต็ปเปอร์
มอเตอร์ นนั่ เอง โดย สเต็ปเปอร์ มอเตอร์ มีดว้ ยกัน 2 แบบคือ
1. Bipolar เป็ นสเต็ปเปอร์มอเตอร์ที่มีขดลวด 2 ขดมีสายไฟให้ต่อใช้งาน 4 เส้นดังรู ปที่ 4.12-1 (a)
2. Unipolar เป็ นสเต็ปเปอร์มอเตอร์ที่มีขดลวด 4 ขด (2 ขดแบบมีแท็ปกลาง) โดยมี 2 แบบ
2.1 แบบมีสายไฟให้ต่อใช้งาน 5 เส้น ดังรู ปที่ 4.12-1 (b)
2.2 แบบมีสายไฟให้ต่อใช้งาน 6 เส้น ดังรู ปที่ 4.12-1 (c)
M M M
(a) (b) (c)

รู ปที่ 4.12-1 โครงสร้างสเต็ปเปอร์ Bipolar และ Unipolar
ใบงานนี้ เลือกใช้สเต็ปเปอร์ มอเตอร์ แบบ Unipolar ซึ่ งมีขดลวดอยู่ภายในจานวน 4 ขด (ที่จริ ง

เป็ น 2 ขดที่มีจุดแท็ปกลาง) โดยจานวนรอบของขดลวดทั้ง 4 ขดจะมีค่าความต้านทานเท่ากัน ดังนั้นก่อน
ใช้งานต้องทาการหาตาแหน่ งสายที่ ใช้งานว่า เป็ นสายตาแหน่ งใดของขดลวด ค่าความต้า นทานของ
ขดลวดของสเต็ปเปอร์ มอเตอร์ ที่มีสายต่อแบบ 5 เส้นเมื่อวัดค่าความต้านทานของสายทุกเส้นจะสามารถ
อ่านค่าได้ทุกเส้นนัน่ หมายความว่าทุกเส้นเชื่ อมต่อถึงกันและมีสายไฟเพียงเส้นเดียวเท่านั้นที่วดั ค่าความ
ต้านทานเทียบกับเส้นอื่น ๆ แล้วมีค่าความต้านทานที่วดั ได้ในแต่ละเส้นเท่ากันทั้งหมด สายไฟเส้นนั้น
เป็ นสายร่ วม นาสายร่ วมต่อกับไฟบวก 5 โวลต์ นาสายไฟเส้นที่เหลือต่อลงกราวด์ครั้งละเส้นเรี ยงกัน โดย
สลับกันไปมา จนกว่าสเต็ปเปอร์ มอเตอร์ หมุนไปทางด้านเดียวกัน สาหรับสเต็ปเปอร์ มอเตอร์ ที่มีสายต่อ
แบบ 6 เส้น เมื่อทาการวัดค่าความต้านทานจะมีเพียง 3 เส้น 2 ชุ ดที่วดั แล้วอ่านค่าความต้านทานได้ และ
ในแต่ละชุ ดจะมีเส้นเดี ยวที่ มีสายร่ วม โดยเมื่อวัดค่าความต้านทานของสายร่ วมกับสายเส้นอื่ น จะมีค่า
ความต้านทานเท่ากัน เมื่อนามาใช้งานจะต้องนาสายร่ วมทั้ง 2 เส้นของทั้ง 2 ชุ ดมาต่อร่ วมกัน (แบบ 5
เส้ นต่ อไว้แล้วภายในตัวมอเตอร์ ) ส าหรั บ วงจรขับ ต้องใช้วงจรขับ ที่ ออกแบบมาส าหรั บ ขับ ขดลวด
เช่ นเดี ยวกับวงจรขับ รี เลย์โดยวงจรต้องมี ไ ดโอดต่ อคร่ อมขดลวดเพื่ อใช้ข จัดแรงดันย้อนกลับ (Back
EMF) ที่เกิดขึ้นเมื่อทรานซิ สเตอร์ หยุดนากระแส วงจรเป็ นดังรู ปที่ 4.12-2
+VS
A B C D
รู ปที่ 4.12-2 แสดงวงจรขับสเต็ปเปอร์มอเตอร์ที่ใช้ทรานซิ สเตอร์
ในทางปฏิบตั ิสามารถใช้ไอซีที่เป็ นทรานซิ สเตอร์ อาร์ เรย์อยูภ่ ายในแทนการใช้ทรานซิ สเตอร์ ได้

โดยไอซี น้ ี มีวงจรภายในเป็ นวงจรทรานซิ สเตอร์ จานวนหลายชุ ด ได้แก่เบอร์ ULN2003, ULN2803 ซึ่ ง
เบอร์ ULN2003 มีวงจรทรานซิสเตอร์ ภายใน 7 ชุด และเบอร์ ULN2803 มี 8 ชุดโดยในแต่ละชุดเป็ นวงจร
ทรานซิ สเตอร์ ที่มีการจัดวงจรภายในเป็ นแบบวงจรทรานซิ สเตอร์ ที่ต่อแบบดาร์ ลิงตัน ซึ่ งสามารถขับ
โหลดกระแสสู งโดยใช้กระแสเบสต่า (ลอจิกที่ป้อนเข้ามาทางอินพุท) จากลักษณะการทางานของวงจรใน
แต่ละชุ ดจะมี ลกั ษณะการทางานเช่ นเดี ยวกับวงจรน็ อตเกตในวงจรดิ จิทลั สาหรับการขับสเต็ปเปอร์
มอเตอร์ จะใช้งานเพียง 4 ชุ ดเท่านั้นดังรู ปที่ 4.12-3 (a) ในกรณี ที่ตอ้ งการขับสเต็ปเปอร์ มอเตอร์ ที่มีกาลัง
มากเป็ นมอเตอร์ ที่ ต้อ งการกระแสสู ง ซึ่ งการขับ กระแสสู ง สามารถใช้ไ อซี เ บอร์ ULN2803 มี ว งจร
ทรานซิ สเตอร์ 8 ชุด โดยทาการขนานกัน 2 ชุ ดต่อการขับมอเตอร์ 1 ขด ดังรู ปที่ 4.12-3 (b) ภายในไอซี มี
ไดโอดป้ องกันแรงดันย้อนกลับ (Back EMF) เตรี ยมไว้สาหรับโหลดที่เป็ นขดลวด ดังนั้นเมื่อใช้งานจริ ง
ไม่ตอ้ งต่อไดโอดเพิ่มภายนอก เพียงแต่ตอ้ งต่อขาร่ วมของไดโอดเข้ากับแหล่งจ่ายที่เชื่ อมเข้าที่จุดร่ วมของ
ขดลวด
+VS
A 1 18 1 18
A +VS
B 2 17 2 17
C 3 16 3 16
B
D 4 15 4 15
5 14 5 14
C
6 13 6 13
7 12 7 12
D
8 11 8 11
9 10 9 10
(a) (b)
รู ปที่ 4.12-3 วงจรขับสเต็ปเปอร์มอเตอร์ แบบใช้ไอซี ULN2803

การขับสเต็ปเปอร์ มอเตอร์
การขับสเต็ปเปอร์มอเตอร์ เป็ นการขับให้มอเตอร์ขยับไปตามจานวนสเต็ปที่ตอ้ งการซึ่ง คุณสมบัติ
ในการขยับในแต่ละสเต็ปของมอเตอร์ มีหลายขนาดให้เลือกใช้งานเช่น 1.8 องศาต่อสเต็ป และ 7.5 องศา
ต่อสเต็ป การควบคุมการหมุนของมอเตอร์สามารถควบคุมการทางานได้ 3 แบบ คือ
1. แบบเต็มสเต็ป 1 เฟส (Full step 1 phase) เป็ นการขับครั้งละ 1 เฟสเรี ยงกันไป ทาให้มอเตอร์
หมุนไปครั้งละ 1 สเต็ป ถ้ามอเตอร์ มีคุณสมบัติ 1.8 องศาต่อสเต็ปก็จะหมุ นไปครั้งละ 1.8 องศา โดยมี
ขั้นตอนขับเฟสดังรู ปที่ 4.12-4
A A A A
D B D B D B D B
C C C C
(a) (b) (c) (d)
รู ปที่ 4.12-4 แสดงการเคลื่อนที่เมื่อขับมอเตอร์แบบเต็มสเต็ป 1 เฟส
ตารางที่ 4.12-1 รู ปแบบการกระตุน้ ขดลวดของมอเตอร์แบบเต็มสเต็ป 1 เฟส

สเต็ปที่ ขดลวด A ขดลวด B ขดลวด C ขดลวด D รู ปที่ 4.12-4
1 ON OFF OFF OFF (a)
2 OFF ON OFF OFF (b)
3 OFF OFF ON OFF (c)
4 OFF OFF OFF ON (d)
2. แบบเต็มสเต็ป 2 เฟส (Full step 2 phase) เป็ นการขับครั้งละ 2 เฟส โดยมีคุณสมบัติที่ดีข้ ึนคือ
แรงบิดมากขึ้นเนื่ องจากมีการขับครั้งละ 2 เฟส ทาให้เกิดสนามแม่เหล็กมากขึ้นนัน่ เอง แต่มุมในการหมุน
จะมีค่าเท่ากันกับแบบเต็มสเต็ป 1 เฟส โดยมีข้ นั ตอนขับเฟสดังรู ปที่ 4.12-5
A A A A
D B D B D B D B
C C C C
(a) (b) (c) (d)
รู ปที่ 4.12-5 แสดงการเคลื่อนที่เมื่อขับมอเตอร์แบบเต็มสเต็ป 2 เฟส
ตารางที่ 4.12-2 รู ปแบบการกระตุน้ ขดลวดของมอเตอร์แบบเต็มสเต็ป 2 เฟส

1 ON ON OFF OFF (a)
2 OFF ON ON OFF (b)
3 OFF OFF ON ON (c)
4 ON OFF OFF ON (d)
3. แบบครึ่งสเต็ป (Haft step) เป็ นการควบคุมให้มอเตอร์ หมุนไปครั้งละครึ่ งของสเต็ปดังนั้นหาก

มอเตอร์มอเตอร์มีคุณสมบัติ 1.8 องศาต่อสเต็ปก็จะหมุนไปครั้งละ 0.9 องศาทาได้ตาแหน่งที่เที่ยงตรงมาก
ขึ้นเมื่อนาไปประยุกต์ใช้งานวิธีการขับจะใช้การผสมกันระหว่างแบบเต็มสเต็ป 1 เฟสกับแบบเต็มสเต็ป 2
เฟส ซึ่ งมีข้ นั ตอนขับเฟสดังรู ปที่ 4.12-6
A A A A
D B D B D B D B
C C C C
(a) (b) (c) (d)
A A A A
D B D B D B D B
C C C C
(e) (f) (g) (h)
รู ปที่ 4.12-6 แสดงการเคลื่อนที่เมื่อขับมอเตอร์แบบครึ่ งสเต็ป

ตารางที่ 4.12-3 รู ปแบบการกระตุน้ ขดลวดของมอเตอร์แบบครึ่ งสเต็ป
1 ON OFF OFF OFF (a)
2 ON ON OFF OFF (b)
3 OFF ON OFF OFF (c)
4 OFF ON ON OFF (d)
5 OFF OFF ON OFF (e)
6 OFF OFF ON ON (f)
7 OFF OFF OFF ON (g)
8 ON OFF OFF ON (h)

pinMode(pin, mode)

delay(ms)
Serial.begin(speed)
analogRead(pin)
value: ตัวแปรที่ตอ้ งการเปลี่ยนแปลงค่า toLow: ตัวเลขต่าสุ ดของค่าที่ตอ้ งการเปลี่ยนไป
fromLow: ตัวเลขต่าสุ ดของค่าจากตัวแปร toHigh: ตัวเลขสู งสุ ดของค่าที่ตอ้ งการเปลี่ยนไป
fromHigh: ตัวเลขสู งสุ ดของค่าจากตัวแปร

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST ULN2803 VCC
C1
0.1uF M1
13 1 OUT1 18 A
D7 IN1
D6 12 2 IN2 M
11 3 OUT2 17 B
D5 IN3
R2,R3 D4 6 4 IN4
USB to UART (TTL Level) 1k OUT3 16 C D
DTR 3
D1(TXD)
OUT4 15
RXD 2
TXD D0(RXD)
+5V VCC
GND
COM 10
3V3
GND
9
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
ULN2803 VCC
M1
OUT1 18 A
D7 13 1 IN1
D6 12 2 IN2 OUT2 17
M
D5 11 3 IN3 B
D4 6 4 IN4 OUT3 16 C D
OUT4 15
VCC
COM 10
GND
GND 9

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
ULN2803A
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1
การทดลองที่ 1 เขียนโปรแกรมควบคุมการทางานของสเต็ปเปอร์ มอเตอร์ โดยให้หมุนในทิศทางเดียวเป็ น
จานวน 360 องศา (ตัวอย่างโปรแกรมใช้สเต็ปเปอร์ มอเตอร์ ที่มีขนาด 1.8 องศาต่อสเต็ป)
START
กาหนดรูปแบบการขับสเต็ป
ครบ 360 อง า?
จริ ง
เท็จ
สั ่งขับสเต็ป ัดไป STOP

1 #define phaseA 4
2 #define phaseB 5
3 #define phaseC 6
4 #define phaseD 7
5 char PinCon[] = {phaseA,phaseB,phaseC,phaseD};
6 byte pattern[]={
7 0B1000,
8 0B0100,
9 0B0010,
10 0B0001};
12 void setup()
13 {
15 {
16 pinMode(PinCon[i],OUTPUT);
17 }
18 }
19 void loop()
20 {
21 for(int j=0;j<50;j++)
22 {
24 {
25 send2port(pattern[i]);
26 delay(55);
27 }
28 }
30 while(1);
31 }
33 {
34 if (data & 1 ){digitalWrite(PinCon[0],HIGH);} else {digitalWrite(PinCon[0],LOW);}
38 }
- บรรทัดที่ 1 กาหนดชื่ อ phaseA ให้แทน 4 (เป็ นขาเฟส A ของสเต็ปเปอร์ มอเตอร์ ที่เชื่ อมต่ออยู่
กับขา D4 ของ Arduino)
- บรรทัดที่ 2 กาหนดชื่อ phaseB ให้แทน 5 (เป็ นขาเฟส B ของสเต็ปเปอร์ มอเตอร์ ที่เชื่ อมต่ออยูก่ บั
ขา D4 ของ Arduino)
- บรรทัดที่ 3 กาหนดชื่อ phaseC ให้แทน 6 (เป็ นขาเฟส C ของสเต็ปเปอร์ มอเตอร์ ที่เชื่ อมต่ออยูก่ บั
ขา D4 ของ Arduino)
- บรรทัดที่ 4 กาหนดชื่ อ phaseD ให้แทน 7 (เป็ นขาเฟส D ของสเต็ปเปอร์ มอเตอร์ ที่เชื่ อมต่ออยู่
กับขา D4 ของ Arduino)
- บรรทัดที่ 5 ประกาศตัวแปรแบบอาร์ เรย์เก็บค่าตาแหน่งของขา Arduino ที่เชื่อมต่อกับมอเตอร์
- บรรทัดที่ 6-10 ประกาศตัวแปรแบบอาร์ เรย์เก็บค่ารู ปแบบการขับสเต็ปเปอร์ มอเตอร์ เป็ นแบบ
ฟูลสเต็ป 1 เฟส
- บรรทัดที่ 21 วนซ้ าจานวน 50 รอบ

- บรรทัดที่ 23 วนซ้ าจานวน 4 รอบ
- บรรทัด ที่ 25 เรี ย กใช้ง านฟั ง ก์ชั่น รองส าหรั บ ขับ สเต็ป พร้ อมส่ ง ค่ า รู ป แบบในการขับ เข้า ใน
ฟังก์ชนั่
- บรรทัดที่ 33-38 ฟังก์ชนั่ รองขับสเต็ปเปอร์ มอเตอร์ ตามรู ปแบบที่รับเข้ามา
1. จาลองการทางานด้วยโปรแกรม Proteus (จากการทดลองหากใช้ delay ต่ากว่า 53 จะทาให้
มอเตอร์ เกิดอาการสะดุดทาให้มุมที่ควรจะได้คลาดเคลื่อนไป)
3. ทดลองแก้โปรแกรมให้มอเตอร์ทางานในรู ปแบบอื่น ๆ แล้วสังเกตผล

1. เขียนโปรแกรมควบคุมการหมุนของสเต็ปเปอร์ มอเตอร์ โดยให้มีการหมุนทวนเข็มและตาม
เข็มนาฬิกาในองศาที่กาหนดขึ้นเอง วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
ULN2803 VCC
M1
13 1 OUT1 18 A
D7 IN1
D6 12 2 IN2 M
11 3 OUT2 17 B
D5 IN3
D4 6 4 IN4 OUT3 16 C D
OUT4 15
VCC
COM 10
GND
GND 9
หมายเหตุ สเต็ปเปอร์ ที่นามาใช้ทดลองอาจมี คุณสมบัติในการขยับตาแหน่ งมีมุมที่ ต่างไปจาก

ตัวอย่างดังนั้นการทดลองจะต้องทราบค่าคุ ณสมบัติของมอเตอร์ ที่นามาใช้งานก่ อนการเขียน
โปรแกรม
ใบงานที่ 4.13 การเขียนโปรแกรมควมคุมเซอร์โวมอเตอร์  173
การเขียนโปรแกรมควบคุมเซอร์ โวมอเตอร์
เพื่อให้สามารถเขียนโปรแกรมควบคุมเซอร์โวมอเตอร์ ได้
1. บอกวิธีเขียนโปรแกรมควบคุมเซอร์โวมอเตอร์ ได้
2.1 Potentiometer 10 k 1 ตัว 2.3 ตัวต้านทาน 220 ohm 1 ตัว
2.2 คันโยกแบบตัวต้านทาน 1 ตัว 2.4 LED 3mm 1 ตัว
5. อาร์ซีเซอร์โวมอเตอร์ 2 ตัว
เซอร์ โวมอเตอร์ เป็ นมอเตอร์ ที่ ส ามารถควบคุ มการเคลื่ อนที่ ไ ปยังมุ มที่ ต้องการได้ด้วยวงจร
ควบคุมแบบป้ อนกลับภายใน เซอร์ โวมอเตอร์ ขนาดเล็กนิ ยมใช้กนั มากในเครื่ องเล่นบังคับวิทยุ เช่น รถ
เรื อ เครื่ องบิน เซอร์ โวมอเตอร์ ประกอบขึ้นจากส่ วนประกอบหลัก ๆ 3 ส่ วนคือ
1. มอเตอร์ไฟฟ้ากระแสตรงขนาดเล็ก
2. ชุดเกียร์ ทดรอบ
3. วงจรควบคุม
รู ปที่ 4.13-1 ภายในเซอร์ โวมอเตอร์ 1
เซอร์ โวมอเตอร์ มีคอนเน็คเตอร์ สาหรับต่อใช้งาน 3 ขา โดยใช้ต่อกับแหล่งจ่ายไฟ 2 ขาและอีก

หนึ่งขาจะใช้ต่อกับสัญญาณควบคุม เซอร์ โวมอเตอร์ ใช้ไฟฟ้ากระแสตรงในการทางานมีแรงดันใช้งานอยู่
ในช่วง 4-6 โวลต์ (สาหรับรุ่ นกาลังแรงบิดสู งจะใช้แรงดันสู งถึง 12 โวลต์) การเรี ยงขาคอนเน็คเตอร์ เป็ น
มาตรฐานแบบเดียวกัน มีความต่างกันบ้างตรงสี ของสายไฟขึ้นอยูก่ บั บริ ษทั ผูผ้ ลิตดังรู ปที่ 4.13-2
รู ปที่ 4.13-2 คอนเน็คเตอร์ เซอร์ โวมอเตอร์ ของแต่ละบริ ษทั 2

1
รู ปจาก http://www.pyroelectro.com
2
รู ปจาก http://www.imagesco.com/servo/connection-types.html
การควบคุ มเซอร์ โวมอเตอร์ ให้เคลื่ อนไปยังมุมที่ ต้องการ สามารถทาได้โดยการส่ งพัล ส์ ที่ มี

ค่าประมาณ 1 ms - 2 ms ดังรู ปที่ 4.13-3 โดยสัญญาณของพัลส์ ใน 1 ลูกคลื่นมีคาบเวลาประมาณ 20 ms
เซอร์ โวมอเตอร์ สามารถเคลื่อนที่ต้ งั แต่มุม 0 องศาจนถึง 180 องศา (ซึ่ งบางตาราอาจกล่าวว่าเคลื่อนตั้งแต่
มุม -90 องศาถึง +90 องศา) ซึ่งโครงสร้างของเซอร์ โวมอเตอร์ ไม่สามารถที่จะหมุนที่มุมเกินกว่าที่กาหนด
ไว้ได้
ในการใช้งานเซอร์ โวมอเตอร์ ที่มีการรับภาระโหลดอาจจะทาให้ตาแหน่ งเคลื่ อนได้หากไม่ส่ง
สัญญาณควบคุ มแบบต่อเนื่ อง โดยปกติโครงสร้ างภายในที่เป็ นเฟื องทดรอบจะทาการล็อกตาแหน่ งไว้
แล้วในระดับหนึ่ งแต่ไม่สามารถคงตาแหน่ งเดิ มไว้ได้หากการต่อใช้งานมีการรับภาระโหลด ในกรณี ที่
ต้องการล็อกตาแหน่งจะต้องส่ งพัลส์ควบคุมตาแหน่งอย่างต่อเนื่ อง
รู ปที่ 4.13-3 สัญญาณพัลส์ที่ใช้ควบคุมเซอร์โวมอเตอร์
การเขียนโค้ดโปรแกรมเพื่อใช้ควบคุมการเคลื่อนที่ของเซอร์ โวมอเตอร์ สามารถเขียนโค้ดโดยไม่

พึ่งไลบรารี่ ก็สามารถทาได้ แต่ถ้าใช้ไลบรารี่ การเขียนโค้ดโปรแกรมก็ง่ายขึ้ นซึ่ งไลบรารี่ ที่ใช้มี ชื่ อว่า
Servo.h เป็ นไลบรารี่ ที่มาพร้ อมกับโปรแกรม Arduino IDE ตั้งแต่ตอนติดตั้งดังนั้นจึงไม่ตอ้ งติดตั้งใหม่
สามารถใช้งานได้ทนั ที

1. ฟังก์ ชั่นกาหนดโหมดการทางานให้ กับขาพอร์ ต โดยสามารถกาหนดได้ท้ งั ขาดิจิตอลโดยใส่
เพียงตัวเลขของขา (0, 1, 2,…13) และขาแอนาลอกที่ตอ้ งการให้ทางานในโหมดดิ จิตอลแต่
งานในโหมดดิจิตอลได้ รู ปแบบของฟังก์ชนั่ เป็ นดังนี้
pinMode(pin, mode);
2. ฟั งก์ ชั่นส่ งค่ าลอจิกดิจิตอลไปยังขาพอร์ ต ค่า HIGH เป็ นการส่ งลอจิก 1 และค่า LOW เป็ น
การส่ งลอจิก 0 ออกไปยังขาพอร์ต ฟังก์ชนั่ นี้ทางานได้ตอ้ งมีการใช้ฟังก์ชนั่ pinMode ก่อน
delay(ms);
4. ฟั งก์ ชั่นอ่ านสั ญญาณแอนาลอก เป็ นฟั งก์ชั่นที่ อ่านสัญญาณแอนาลอกที่ ปรากฏอยู่ที่ ข าที่
ต้องการอ่านนั้น ๆ ค่าที่อ่านได้จะอยูใ่ นช่วง 0-1023 สาหรับแรงดันของสัญญาณแอนาลอกที่
0-5V ดังนั้นต้องใช้ตวั แปรที่เป็ น int สาหรับเก็บค่าที่อ่านได้
analogRead(pin);
map(value, fromLow, fromHigh, toLow, toHigh);
ฟังก์ชั่นใช้ งานของไลบรารี่ Servo.h

การใช้งานเซอร์ โวมอเตอร์ หากใช้ไลบรารี่ ช่วยงานจะทาให้สะดวก การควบคุมเซอร์ โวมอเตอร์
จานวนหลาย ๆ ตัวพร้อม ๆ กันเขียนโค้ดง่าย ซึ่ งไลบรารี่ มีมาพร้อมกับโปรแกรม Arduino IDE แล้ว
Servo.h ไม่ตอ้ งดาวน์โหลดเนื่องจากมาพร้อมกับ Arduino IDE
1. ฟั งก์ ชั่ น ประกาศชื่ อ เซอร์ โวมอเตอร์ ใช้ใ นการระบุ ชื่ อ ใช้แทนเซอร์ โวมอเตอร์ ที่ ใ ช้ง าน
Servo myservo;
หมายถึง ต่อไปในโปรแกรมจะใช้ชื่อ myservo ในการเรี ยกใช้งานเซอร์ โวมอเตอร์ ที่กาลังต่อใช้
งานกับ Arduino
2. ฟังก์ชั่นกาหนดขาเชื่ อมต่ อ ใช้กาหนดขาที่ใช้เชื่อมต่อกับเซอร์ โวมอเตอร์ รูปแบบเป็ นดังนี้

.attach(pin);
pin: ตัวเลขพอร์ ตที่ทาการเชื่อมต่อกับเซอร์ โวมอเตอร์
ตัวอย่าง myservo.attach(9);
หมายถึง เซอร์ โวมอเตอร์ ที่ชื่อว่า myservo มีการเชื่อมต่อที่ขา D9
3. ฟั งก์ ชั่ น สั่ งให้ เซอร์ โวหมุ นไปยังมุ ม ที่ก าหนด ใช้สั่ ง ให้เซอร์ โวมอเตอร์ หมุ นไปยัง มุ ม ที่
กาหนดซึ่ งค่ามุมที่สามารถป้ อนอยูใ่ นระหว่าง 0-180 รู ปแบบเป็ นดังนี้
.write(val);
val: ตัวเลขมุมที่ตอ้ งการให้เซอร์โวมอเตอร์เคลื่อนที่ไป
ตัวอย่าง myservo.write(45);
หมายถึง เซอร์ โวมอเตอร์ ที่ชื่อว่า myservo เคลื่อนที่ไปยังมุม 45 องศา
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
Potentiometer
A5 28 10k
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC RC Servo Motor
D9 15 Signal
VCC
GND
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


VCC ARDUINO
VCC
5V
Potentiometer
A5 10k
VCC RC Servo Motor
D9 Signal
VCC
GND
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1

การทดลองที่ 1 เขียนโปรแกรมควบคุมการเคลื่อนที่ของเซอร์ โวมอเตอร์ ไปที่มุมต่าง ๆ โดยรับค่าจากการ
หมุนโพเทนธิโอมิเตอร์
START
แปลงย่ านตัวเลข
ขับเซอร์ โวมอเตอร์

1 #include <Servo.h>
2 #define pot 5
3 Servo myservo; // create servo object to control a servo
4 void setup()
5 {
6 myservo.attach(9); // attaches the servo on pin 9 to the servo object
7 }
8 void loop()
9 {
10 int val = analogRead(pot); // reads the value of the potentiometer
11 val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo
12 myservo.write(val); // sets the servo position
13 delay(15); // waits for the servo to get there
14 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ Servo.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 กาหนดชื่อ pot ให้แทน 5 (โพเทนธิ โอมิเตอร์ เชื่ อมต่ออยูก่ บั ขา A5 ของ Arduino)
- บรรทัดที่ 3 ประกาศใช้งานไลบรารี่ โดยกาหนดชื่อ myservo ให้แทนเซอร์โวมอเตอร์ ที่ใช้งาน
- บรรทัดที่ 6 กาหนดขาพอร์ ตที่ใช้เชื่อมต่อกับเซอร์ โวมอเตอร์
- บรรทัดที่ 10 อ่านค่าแอนาลอกจากโพเทนธิ โอมิเตอร์ เอามาเก็บไว้ในตัวแปร val
- บรรทัดที่ 11 เปลี่ยนย่านตัวเลขจากค่าแอนาลอก 0-1023 ไปเป็ น 0-180
- บรรทัดที่ 12 สั่งให้เซอร์ โวขยับไปยังมุมที่ได้จากค่าในตัวแปร val
3. ทดลองปรับแก้ค่าย่านตัวเลขให้เป็ นค่าอื่นแล้วสังเกตผล

เขียนโปรแกรมควบคุมเซอร์ โวมอเตอร์ จานวน 2 ตัวโดยใช้คนั โยก (จอยสติก) แบบตัวต้านทาน
พร้อมทั้งเขียนโค้ดสั่งให้ LED ติดเมื่อกดสวิตช์ที่อยูบ่ นหัวของคันโยก
GND
GND
+5V +5V
To Analog in VRx
VRy
To Analog in SW
To Digital in
รู ปที่ 4.13-8 ลักษณะของคันโยก รู ปที่ 4.13-9 การเชื่อมต่อใช้งาน
วงจรที่ใช้ทดลอง
VCC ARDUINO VCC
GND
5V +5V
A3 VRx
VRy
SW
A5
D7
VCC RC Servo Motor
D8 Signal
VCC
D9 GND
R1 220
D10 RC Servo Motor
VCC
Signal
LED1 VCC
GND GND

ใบงานที่ 4.14 การเขียนโปรแกรมใช้งานอินเตอร์รัพท์  181
การเขียนโปรแกรมใช้ งานอินเตอร์ รัพท์
เพื่อให้สามารถเขียนโปรแกรมใช้งานอินเตอร์ รัพท์ได้
1. บอกวิธีเขียนโปรแกรมใช้งานอินเตอร์รัพท์ได้
2.1 ตัวต้านทาน 220 ohm 6 ตัว 2.3 ตัวเก็บประจุ 1uF 2 ตัว
2.2 LED 3mm 4 ตัว 2.4 Tack Switch 2 ตัว
การขัดจังหวะการทางานหรื อเรี ยกทับศัพท์วา่ การอินเตอร์ รัพต์ (Interrupt) เป็ นการขัดจังหวะการ
ทางานปกติ (ประมวลผลในโปรแกรมหลัก) ของไมโครคอนโทรลเลอร์ โดยจะกระโดดไปทางานใน
โปรแกรมตอบสนองการอินเตอร์ รัพท์ในตาแหน่งที่ตอบสนองการอินเตอร์ รัพท์ (Interrupt Vector) ชนิด
นั้น ๆ เมื่ อทางานในโปรแกรมตอบสนองการอิ นเตอร์ รัพท์เสร็ จสิ้ นซี พียูจะกระโดดกลับมาทางานใน
ตาแหน่ ง เดิ ม ของโปรแกรมหลัก ต่ อไป ไมโครคอนโทรลเลอร์ ใ นทุ ก ตระกู ล จะมี อิน เตอร์ รัพ ท์ที่ ไ ม่
สามารถปฏิเสธได้ 1 ชนิดได้แก่ Reset กล่าวคือเมื่อซี พียไู ด้รับสัญญาณอินเตอร์ รัพท์ชนิดนี้ไม่วา่ จะทางาน
ในคาสั่งใดอยูก่ ็ตามจะต้องกลับไปทางานในตาแหน่ง 0x0000 ซึ่ งเป็ นตาแหน่งแรกของโปรแกรม บอร์ ด
Arduino ในรุ่ นที่ใช้ไมโครคอนโทรลเลอร์ ตระกูล AVR เบอร์ Atmega328 สามารถอินเตอร์ รัพท์ได้จาก
หลายแหล่งโดยแต่ละแหล่งมีตาแหน่งตอบสนองการอินเตอร์ รัพท์ที่แตกต่างกันไปดังตารางที่ 4.14-1
ตารางที่ 4.14-1 Reset and Interrupt Vectors in ATmega328P

Vector Program
Source Interrupt Definition
No. Address
External pin, power-on reset, brown-out reset and watchdog
1 0x0000 RESET
system reset
2 0x0002 INT0 External interrupt request0
3 0x0004 INT1 External interrupt request1
4 0x0006 PCINT0 Pin change Interrupt request 0
5 0x0008 PCINT1 Pin change interrupt request 1
6 0x000A PCINT2 Pin change interrupt request 2
7 0x000C WDT Watchdog time-out interrupt
8 0x000E TIMER2 COMPA Timer/Counter2 compare match A
9 0x0010 TIMER2 COMPB Timer/Counter2 compare match B
10 0x0012 TIMER2 OVF Timer/Counter2 overflow
11 0x0014 TIMER1 CAPT Timer/Counter1 capture event
12 0x0016 TIMER1 COMPA Timer/Counter1 compare match A
13 0x0018 TIMER1 COMPB Timer/Counter1 compare match B
14 0x001A TIMER1 OVF Timer/Counter1 overflow
15 0x001C TIMER0 COMPA Timer/Counter0 compare match A
16 0x001E TIMER0 COMPB Timer/Counter0 compare match B
17 0x0020 TIMER0 OVF Timer/Counter0 overflow
18 0x0022 SPI, STC SPI serial transfer complete
19 0x0024 USART, RX USART Rx complete
20 0x0026 USART, UDRE USART, data register empty
21 0x0028 USART, TX USART, Tx complete
22 0x002A ADC ADC conversion complete
23 0x002C EE READY EEPROM ready
24 0x002E ANALOG COMP Analog comparator
25 0x0030 TWI 2-wire serial interface
26 0x0032 SPM READY Store program memory ready
ใบงานนี้เป็ นการเรี ยนรู ้การอินเตอร์ รัพท์ที่รับการกระตุน้ จากสัญญาณภายนอกซึ่ งสามารถรับการ

อินเตอร์ รัพท์ได้ 2 แหล่งคือ INT0 (ขา D2) และ INT1 (ขา D3) เนื่องจากใบงานใช้ Arduino รุ่ น Nano ใน
การทดลอง แต่สาหรับบอร์ ด Arduino ในรุ่ นอื่น ๆ สามารถรับสัญญาณอินเตอร์ รัพท์จากขาที่แตกต่างกัน
ดังตารางที่ 4.14-2
ตารางที่ 4.14-2 ขาดิจิทลั ที่พร้อมใช้งานอินเตอร์รัพท์ของบอร์ด Arduino ในรุ่ นต่าง ๆ

Board Digital Pins Usable for Interrupts
Uno, Nano, Mini, other 328-based 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
Micro, Leonardo, other 32u4-based 0, 1, 2, 3, 7
Zero all digital pins, except 4
MKR1000 Rev.1 0, 1, 4, 5, 6, 7, 8, 9, A1, A2
Due all digital pins
all digital pins
101
(Only pins 2, 5, 7, 8, 10, 11, 12, 13 works with CHANGE)
ตารางที่ 4.14-3 ชนิดของอินเตอร์รัพท์ของบอร์ ด Arduino ในรุ่ นต่าง ๆ

Board int.0 int.1 int.2 int.3 int.4 int.5
Uno, Nano, Mini, Ethernet 2 3
Mega2560 2 3 21 20 19 18
32u4 based (e.g Leonardo, Micro) 3 2 0 1 7
Due, Zero, MKR1000, 101 interrupt number = pin number
Arduino เป็ นไมโครคอนโทรลเลอร์ ที่ทางานด้วยความเร็ วสู งดังนั้นเมื่อใช้งานวงจรสวิตช์ทวั่ ไป

ดังรู ป 4.14-1 จะทาให้เกิ ดสัญญาณรบกวนได้ สัญญาณรบกวนนี้ เรี ยกว่าสัญญาณกระเด้งกระดอนหรื อ
เรี ยกทับศัพท์วา่ สัญญาณเบาส์ (Bouncing signal) ซึ่ งการกดเพียงหนึ่งครั้งจะเกิดสัญญาณรบกวนขึ้นทาให้
ไมโครคอนโทรลเลอร์ ที่ทางานด้วยความเร็ วสู งเข้าใจว่ากดหลายครั้งส่ งผลทาให้เกิ ดการประมวลผลที่
คลาดเคลื่อนไป ดังนั้นเมื่อใช้งานจริ งสามารถใช้วธิ ี การแก้ได้ 2 แบบคือ
1. แก้ด้วยฮาร์ ดแวร์ โดยการต่อตัวเก็บประจุคร่ อมสวิตช์ดงั รู ปที่ 4.14-2
2. แก้ด้วยซอฟท์แวร์ โดยการหน่วงเวลาเมื่อได้รับสัญญาณไปช่วงเวลาหนึ่งแล้วตรวจสอบอีกครั้ง
VCC
Switch contacts
bouncing
R
10k 5V
VOUT
SW
0V
closed open
Switch position
รู ปที่ 4.14-1 วงจรสวิตช์ทวั่ ไป

VCC
Switch contacts
debouncing
R
10k 5V
SW VOUT
C
0V
closed open
Switch position
รู ปที่ 4.14-2 วงจรสวิตช์ที่ได้รับการแก้ไข

pinMode(pin, mode);

ตรวจสอบลอจิกทีหลังหรื อจะตรวจสอบลอจิกแบบทันทีก็ได้ ซึ่ งฟั งก์ชนั่ นี้ จะทางานได้ตอ้ ง
มีการใช้ฟังก์ชนั่ pinMode ก่อน
digitalRead(pin);

delay(ms);

ฟังก์ชั่นใช้ งานอินเตอร์ รัพท์

Arduino เตรี ยมฟังก์ชนั่ เกี่ยวกับอินเตอร์ รัพท์ให้ใช้งานทั้งหมด 4 ฟังก์ชนั่ ด้วยกันคือ
- attachInterrupt() เปิ ดการใช้งานอินเตอร์รัพท์จากขาอินเตอร์ รัพท์ภายนอก
- detachInterrupt() ปิ ดการใช้งานอินเตอร์รัพท์จากขาอินเตอร์ รัพท์ภายนอก
- interrupts() เปิ ดการใช้งานอินเตอร์รัพท์อีกครั้ง
- noInterrupts() ปิ ดการใช้งานอินเตอร์ รัพท์ท้ งั หมด
1. ฟั งก์ ชั่นเปิ ดการใช้ งานอินเตอร์ รัพท์ จากขาอินเตอร์ รัพท์ ภายนอก ค่าเริ่ มต้นของ Arduino
ไม่ได้เปิ ดการใช้งานส่ วนนี้ ไว้โดยขาใช้งานได้นาไปใช้งานเป็ นขาดิจิทลั ปกติ ในทางปฏิบตั ิ
โปรแกรมตอบสนองการอินเตอร์ รัพท์จะต้องสั้นเพื่อให้ซีพียูได้ทางานเสร็ จสิ้ นด้วยความ
รวดเร็ ว เนื่ องจากเมื่อกาลังทาโปรแกรมตอบสนองการอินเตอร์ รัพท์อยูน่ ้ นั ฟั งชัน่ อื่นที่มีการ
ใช้งานอินเตอร์ รัพท์จะไม่สามารถใช้งานได้เช่ น delay(), millis() และหากมีการใช้งานตัว
แปรที่ เป็ นตัวแปรโกลบอลจะต้องประกาศด้า นหน้า ว่า volatile เพื่อให้ค่าที่ นาไปใช้ง าน
อินเตอร์ รัพท์ได้รับค่าหรื อกาหนดค่าเพื่อส่ งกลับเข้าโปรแกรมหลักได้อย่างถูกต้อง รู ปแบบ

ของฟังก์ชนั่ เปิ ดการใช้งานนี้มี 2 แบบด้วยกันคือ
- แบบทีก่ าหนดชื่ อขาดิจิทลั
attachInterrupt(digitalPinToInterrupt(pin), ISR, mode);
pin: หมายเลขขาดิจิทลั ที่สามารถใช้งานได้เช่น D2 ใส่ เฉพาะเลข 2
ISR: ชื่อฟังก์ชนั่ รองที่ใช้ตอบสนองการอินเตอร์ รัพท์
mode: เป็ นการกาหนดลักษณะของสัญญาณที่ใช้กระตุน้ การอินเตอร์ รัพท์
LOW เมื่อขาเป็ นลอจิกศูนย์
CHANGE เมื่อขามีการเปลี่ยนระดับลอจิก 1->0, 0->1
RISING เมื่อขามีการเปลี่ยนระดับลอจิกจาก 0 ไปเป็ น 1
FALLING เมื่อขามีการเปลี่ยนระดับลอจิกจาก 1 ไปเป็ น 0
- แบบทีก่ าหนดชนิดของอินเตอร์ รัพท์
attachInterrupt(interrupt, ISR, mode);
interrupt: หมายเลขขาอินเตอร์ รัพท์เช่น INT0(D2) ใส่ เฉพาะเลข 0
ISR: ชื่อฟังก์ชนั่ รองที่ใช้ตอบสนองการอินเตอร์ รัพท์
mode: เป็ นการกาหนดลักษณะของสัญญาณที่ใช้กระตุน้ การอินเตอร์ รัพท์
LOW เมื่อขาเป็ นลอจิกศูนย์
CHANGE เมื่อขามีการเปลี่ยนระดับลอจิก 1->0, 0->1
RISING เมื่อขามีการเปลี่ยนระดับลอจิกจาก 0 ไปเป็ น 1
FALLING เมื่อขามีการเปลี่ยนระดับลอจิกจาก 1 ไปเป็ น 0
2. ฟังก์ชั่นปิ ดการใช้ งานอินเตอร์ รัพท์จากขาอินเตอร์ รัพท์ภายนอก เป็ นฟังก์ชนั่ ที่ปิดการใช้งาน

การอินเตอร์รัพท์ในขานั้น ๆ โดยขาที่ถูกปิ ดจะกลับไปเป็ นขาดิจิทลั ดังเดิมรู ปแบบดังนี้
detachInterrupt(digitalPinToInterrupt(pin));
detachInterrupt(interrupt);
pin: หมายเลขขาดิจิทลั ที่สามารถใช้งานได้เช่น D2 ใส่ เฉพาะเลข 2
interrupt: หมายเลขขาอินเตอร์ รัพท์เช่น INT0(D2) ใส่ เฉพาะเลข 0
3. ฟั ง ก์ ชั่ น เปิ ดการใช้ งานอิน เตอร์ รั พ ท์ อีก ครั้ ง เป็ นฟั ง ก์ ชั่น ที่ ใ ช้เ มื่ อ ต้อ งการเปิ ดให้ มี ก าร
อินเตอร์ รัพท์ได้อีกครั้งหลังจากการถูกสั่งปิ ดการอินเตอร์ รัพท์จากฟังก์ชนั่ noInterrupts();
interrupts();
4. ฟังก์ ชั่นปิ ดการใช้ งานอินเตอร์ รัพท์ เป็ นฟั งก์ชนั่ ที่ใช้ปิดการอินเตอร์ รัพท์ทุกชนิ ด ดังนั้นเมื่อ
ใช้งานฟังก์ชนั่ นี้แล้วฟังก์ชนั่ อื่น ๆ ที่มีการใช้งานอินเตอร์ รัพท์จะใช้งานไม่ได้เช่น delay();
noInterrupts();

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC R4-R8
SW1 220 LED1-LED3
1 AVCC
RST 15
D9
C1
0.1uF 16
D10
17
D11
R2,R3 18
D12
DTR 3 VCC
RXD D1(TXD)
2
TXD D0(RXD)
+5V Internal pull up
GND
3V3 R9,R10
220 x2 SW2
4
(INT0)D2
SW3
5
(INT1)D3
X1 C4,C5
16MHz 9 1uF 16V
XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
R1-R3 LED1-LED3
220
D9
D10
D11
D12
VCC
Internal pull up
R4-R5
220 x2 SW1
(INT0)D2
SW2
(INT1)D3
C1-2
GND 1uF 16V

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมทดสอบฟั งก์ชนั่ noInterrupts(); และ interrupts(); โดยการสั่งให้ LED ติด
และดับโดยใช้ฟังก์ชนั่ หน่วงเวลาพร้อมแสดงการนับเลขสังเกตผลที่เกิดขึ้น
START
กาหนดค่าเริ ่มต้ นต่ า ง A

B
ปิ ดการอินเตอร์ รัพท์ เปิ ดการอินเตอร์ รัพท์
จริ ง จริ ง
ครบ 20 รอบ? A ครบ 20 รอบ? B
เท็จ เท็จ
สั ่ง LED ติด ดับ สั ่ง LED ติด ดับ
ส่ งค่ า ตัวเลขไปแสดงผล ส่ งค่ า ตัวเลขไปแสดงผล

1 #define LED 12
2 byte state = LOW;
3 void setup() {
6 }
7 void loop() {
8 noInterrupts();
9 Serial.print("Disable Interrupt :");
10 for(int i=1;i<=20;i++)
11 {
12 Serial.print("-");Serial.print(i);delay(250);
13 state = !state;
14 digitalWrite(LED, state);
15 }
16 Serial.println("");
17 interrupts();
18 Serial.print("Enable Interrupt :");
19 for(int i=1;i<=20;i++)
20 {
21 Serial.print(".");Serial.print(i);delay(250);
22 state = !state;
24 }
26 }
- บรรทัดที่ 1 กาหนดชื่อ LED ให้แทน 12 (เป็ นขาที่ LED ต่ออยูก่ บั ขา D12 ของ Arduino)
- บรรทัดที่ 2 ประกาศตัวแปรสาหรับเก็บสถานะของ LED โดยให้ค่าเริ่ มต้นเป็ น LOW

- บรรทัดที่ 5 กาหนดความเร็ วในการสื่ อสารผ่านพอร์ ตอนุกรมที่ 9600 bps
- บรรทัดที่ 8 ปิ ดการอินเตอร์รัพท์
- บรรทัดที่ 9 แสดงข้อความว่า "Disable Interrupt :"
- บรรทัดที่ 11-15 วนแสดงเลขนับรอบพร้อมสัง่ ให้ LED ติด/ดับ
- บรรทัดที่ 17 เปิ ดการอินเตอร์รัพท์
- บรรทัดที่ 18 แสดงข้อความว่า "Enable Interrupt :"
- บรรทัดที่ 19-24 วนแสดงเลขนับรอบพร้อมสั่งให้ LED ติด/ดับ
3. สังเกตผลที่เกิดขึ้นในจังหวะที่มีการสั่งปิ ดและเปิ ดการอินเตอร์ รัพท์ (ฟังก์ชนั่ delay จะไม่
ทางานเมื่อมีการสั่งปิ ดอินเตอร์ รัพท์)
การทดลองที่ 2 เขียนโปรแกรมควบคุมการติดดับของ LED ด้วยสวิตช์โดยวิธีอินเตอร์ รัพท์ ในขณะที่ยงั

ไม่มีการกดสวิตช์ให้แสดงผลการนับรอบเพื่อให้รู้วา่ กาลังวนทางานอยูใ่ นส่ วนใด
START
START
กลับค่าตัวแปรส านะ
เปิ ดการอินเตอร์ รัพท์ภายนอก
จริ ง แสดงข้ อความว่า ูก
ครบ 20 รอบ? อินเตอร์ รัพท์ แล้ ว
เท็จ
STOP
ส่ งตัวเลขไปแสดงผล
ฟั งก์ชนั ่ ตอบสนองการอินเตอร์ ร ัพท์
สั ่ง LED ติด ดับ
ตามตัวแปรส านะ

1 #define LED 12
2 #define interruptPin 2
3 volatile byte state = LOW;
4 void setup()
5 {
7 pinMode(interruptPin, INPUT_PULLUP);
8 attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE);
10 }
11 void loop() {
12 // noInterrupts();
13 Serial.print("Test :");
14 for(int i=1;i<=20;i++)
15 {
16 Serial.print("-");
17 Serial.print(i);
18 delay(250);
20 }
22 }
23 void blink()
24 {
25 state = !state;
27 Serial.println("Interrupted");
28 }
- บรรทัดที่ 1 กาหนดชื่อ LED ให้แทน 12 (เป็ นขาที่ LED ต่ออยูก่ บั ขา D12 ของ Arduino)
- บรรทัดที่ 2 กาหนดชื่อ interruptPin ให้แทน 2 (เป็ นขาที่สวิตช์ต่ออยูก่ บั ขา D2 ของ Arduino)
- บรรทัดที่ 3 ประกาศตัวแปรสาหรับเก็บสถานะของ LED โดยให้ค่าเริ่ มต้นเป็ น LOW
- บรรทัดที่ 7 กาหนดโหมดให้กบั ขาพอร์ ตที่ต่อกับสวิตช์ทางานเป็ นอินพุทแบบพูลอัพ
- บรรทัดที่ 8 เปิ ดการอินเตอร์รัพท์ภายนอกโดยรับสัญญาณแบบ CHANGE
- บรรทัดที่ 14-20 แสดงตัวเลขนับรอบพร้อมสั้งให้ LED ติด/ดับตามตัวแปรเก็บสถานะ
- บรรทัดที่ 23-28 ฟังก์ชนั่ ตอบสนองการอินเตอร์ รัพท์ โดยสั่งกลับค่าตัวแปรเก็บสถานะและแสดง
ข้อความว่าเกิดการอินเตอร์ รัพท์ข้ ึนแล้ว
3. ทดลองกดสวิตช์แล้วสังเกตผลที่เกิดขึ้น
4. ทดลองเปลี่ยนรู ปแบบของลักษณะสัญญาณอินเตอร์ รัพท์เป็ น LOW, CHANGE, RISING,
FALLING
5. ทดลองใช้และไม่ใช้วงจรแก้สัญญาณรบกวนดังรู ปที่ 4.14-7 (a) และ (b) สังเกตผลที่เกิดขึ้น
R1, R2 R1, R2
220 x2 SW1 220 x2 SW1
(INT0)D2 (INT0)D2
SW2 SW2
(INT1)D3 (INT1)D3
C1, C2
1uF 16V
(a) (b)
รู ปที่ 4.14-7 วงจรแก้สัญญาณรบกวน


1. เขี ย นโปรแกรมไฟวิ่ ง LED 4 ตัว โดยก าหนดรู ป แบบการติ ด /ดับ ตามต้อ งการพร้ อ มให้
สามารถรับการอินเตอร์ รัพท์ได้ โดยเมื่อกดสวิตช์ SW1 ให้ LED ทุกตัวดับหมดและเมื่อกด
สวิตช์ SW2 ให้ LED ทุกตัวติดสว่างทั้งหมดวงจรที่ใช้ทดลองดังรู ป
ARDUINO
R1-R3 LED1-LED3
220
D9
D10
D11
D12
VCC
Internal pull up
R4-R5
220 x2 SW1
(INT0)D2
SW2
(INT1)D3
C1-2
GND 1uF 16V

ใบงานที่ 4.15 การเขียนโปรแกรมใช้งานหน่วยความจา EEPROM  193
การเขียนโปรแกรมใช้ งานหน่ วยความจา EEPROM
เพื่อให้สามารถเขียนโปรแกรมใช้งานหน่วยความจา EEPROMได้
1. บอกวิธีเขียนโปรแกรมใช้งานหน่วยความจา EEPROMได้
2.1 ตัวต้านทาน 220 ohm 5 ตัว 2.3 ตัวเก็บประจุ 1uF 2 ตัว
2.2 LED 3mm 1 ตัว 2.4 Tack Switch 4 ตัว
EEPROM (Electrically Erasable Programmable Read-Only Memory) หรื อ E2PROM สาหรับ
การออกเสี ย งสามารถเรี ยกได้ ห ลายแบบได้ แ ก่ อี อี พ รอม ดับ เบิ ล อี พ รอม หรื ออี ส แควร์ พ รอม
หน่วยความจาชนิ ดนี้เป็ นหน่วยความจาประเภทกึ่งถาวรกล่าวคือเป็ นหน่ วยความจาที่สามารถเขียนและ
ลบได้โ ดยใช้แ รงดัน ไฟฟ้ า ปกติ ไ ด้แ ละข้อ มู ล ที่ บ รรจุ อ ยู่ภ ายในสามารถคงค่ า อยู่ไ ด้ใ นสภาพที่ ไ ม่ มี
ไฟเลี้ ยงวงจร (non-volatile memory) หน่ วยความจาชนิ ดนี้ มีอายุการใช้งานจากัดตามวงรอบของการ
เขียนข้อมูล ดังนั้นการใช้งานจึงใช้เก็บข้อมูลที่จาเป็ นที่ตอ้ งคงค่านั้นเพื่อนามาใช้งานใหม่ได้ในกรณี ที่
หยุดจ่ายไฟให้กบั วงจร เช่นการตั้งค่าโหมดการทางาน การตั้งค่าสู งสุ ดต่าสุ ด การตั้งเวลาทางานของวงจร
เป็ นต้น บอร์ด Arduino ในแต่ละรุ่ นมีการใช้ซีพียแู ตกต่างกันซึ่ งซี พียแู ต่ละเบอร์ มีหน่วยความจาชนิ ดนี้ ที่มี
ขนาดแตกต่างกันดังตาราง 4.15-1
ตารางเปรี ยบเทียบคุณสมบัติของ Arduino ในแต่ละรุ่ น (เฉพาะบางรุ่ น)
Name Processor EEPROM[KB] SRAM [KB] Flash [KB]
101 Intel® Curie - 24 196
Gemma ATtiny85 0.5 0.5 8
ATmega168V
LilyPad 0.512 1 16
ATmega328P
LilyPad SimpleSnap ATmega328P 1 2 32
LilyPad USB ATmega32U4 1 2.5 32
Mega 2560 ATmega2560 4 8 256
Micro ATmega32U4 1 2.5 32
ATmega168 0.512 1 16
Pro
ATmega328P 1 2 32
Pro Mini ATmega328P 1 2 32
Uno ATmega328P 1 2 32
Zero ATSAMD21G18 - 32 256
Due ATSAM3X8E - 96 512
Esplora ATmega32U4 1 2.5 32
Ethernet ATmega328P 1 2 32
Leonardo ATmega32U4 1 2.5 32
Mega ADK ATmega2560 4 8 256
Mini ATmega328P 1 2 32
ATmega168 0.512 1 16
Nano
ATmega328P 1 2 32
ATmega32U4 2.5 32
Yùn 1
AR9331 Linux 16MB 64MB
บอร์ ด Arduino รุ่ นที่ ใช้ในการทดลองนี้ เป็ นรุ่ น Nano ใช้ซีพียูตระกูล AVR เบอร์ ATmega328
ซึ่ งมี หน่ วยความจา EEPROM ขนาด 1 Kbyte (1024 byte) จากข้อมูลในดาต้าชี ต ระบุ วงรอบการเขี ย น
ข้อมูลลงหน่วยความจาสามารถใช้งานได้ประมาณ 100,000 ครั้ง

1. ฟังก์ ชั่นกาหนดโหมดการทางานให้ กับขาพอร์ ต โดยสามารถกาหนดได้ท้ งั ขาดิจิทลั โดยใส่
pinMode(pin, mode);
ส่ งลอจิก 0 ออกไปยังขาพอร์ต ซึ่ งฟังก์ชนั่ นี้จะทางานได้ตอ้ งมีการใช้ฟังก์ชนั่ pinMode ก่อน
ตรวจสอบลอจิกทีหลังหรื อจะตรวจสอบลอจิกแบบทันทีก็ได้ ซึ่ งฟั งก์ชนั่ นี้ จะทางานได้ตอ้ ง
มีการใช้ฟังก์ชนั่ pinMode ก่อน
digitalRead(pin);
delay(ms);
ฟังก์ชั่นใช้ งานหน่ วยความจา EEPROM

การใช้งานหน่ วยความจา EEPROM จาเป็ นต้องใช้ไลบรารี่ ช่วยงาน ซึ่ งไลบรารี่ มีมาพร้ อมกับ
โปรแกรม Arduino IDE แล้วไม่ตอ้ งติดตั้งใหม่
EEPROM.h ไม่ตอ้ งดาวน์โหลดเนื่องจากมาพร้อมกับ Arduino IDE
Arduino เตรี ยมฟังก์ชนั่ เกี่ยวกับหน่วยความจา EEPROM ให้ใช้งานหลัก ๆ ดังนี้
- read() อ่านค่าจากหน่วยความจาขนาด 1 ไบต์ในแอดแดรสที่กาหนด
- write() เขียนค่าลงหน่วยความจาขนาด 1 ไบต์ในแอดแดรสที่กาหนด
- update() เขียนค่าลงหน่วยความจาเฉพาะข้อมูลที่เป็ นค่าใหม่
- get() อ่านค่าจากหน่วยความจาตามขนาดตัวแปรในแอดแดรสที่กาหนด
- put() เขียนค่าลงหน่วยความจาตามขนาดตัวแปรในแอดแดรสที่กาหนด
1. ฟังก์ ชั่นอ่ านข้ อมูลขนาด 1 ไบต์ เป็ นฟั งก์ชนั่ ที่อ่านข้อมูลครั้งละ 1 ไบต์ตามแอดเดรสที่ระบุ
โดยข้อมูลที่อ่านได้จะมีค่าอยูร่ ะหว่าง 0-255 ในเลขฐานสิ บ รู ปแบบเป็ นดังนี้
.read(address);
address: หมายเลขตาแหน่งของหน่วยความจาที่ตอ้ งการอ่านค่า
2. ฟังก์ชั่นเขียนข้ อมูลขนาด 1 ไบต์ เป็ นฟังก์ชนั่ ที่บนั ทึกข้อมูลขนาด 1 ไบต์ลงในหน่วยความจา
EEPROM ในตาแหน่งที่ระบุ รู ปแบบดังนี้
.write(address, value);
address: หมายเลขตาแหน่งของหน่วยความจาที่ตอ้ งการบันทึก
value: ค่าที่ตอ้ งการบันทึกลงหน่วยความจามีค่าระหว่าง 0-255
3. ฟังก์ ชั่นบันทึกข้ อมูลขนาด 1 ไบต์ เฉพาะค่ าที่เปลี่ยนแปลง เป็ นฟั งก์ชนั่ ที่บนั ทึกข้อมูลขนาด
1 ไบต์ลงในหน่ วยความจา EEPROM ในตาแหน่ งที่ระบุโดยฟั งก์ชนั่ นี้ จะตรวจสอบว่าค่าที่
ต้องการบันทึกเป็ นค่าที่ไม่ตรงกับค่าที่มีอยูเ่ ดิมทาให้ลดจานวนวงรอบการเขียนข้อมูลทาให้
อายุการใช้งานยาวนานขึ้น รู ปแบบดังนี้
.update(address, value);
value: ค่าที่ตอ้ งการบันทึกลงหน่วยความจามีค่าระหว่าง 0-255
4. ฟังก์ชั่นอ่ านข้ อมูลตามขนาดตัวแปรในตาแหน่ งทีร่ ะบุ รู ปแบบเป็ นดังนี้
.get(address, data);
address: หมายเลขตาแหน่งของหน่วยความจาที่ตอ้ งการอ่านค่า
data: ตัวแปรที่ตอ้ งการเก็บค่าที่ได้จากการอ่าน
5. ฟังก์ชั่นบันทึกข้ อมูลตามขนาดตัวแปรในตาแหน่ งทีร่ ะบุ รู ปแบบเป็ นดังนี้
.put(address, data);
data: ตัวแปรที่ตอ้ งการบันทึกค่าลงหน่วยความจา
R1 LED1
220
D9
VCC
Internal pull up
R2-R4
220 x2 SW1
D5
SW2
D4
SW3
(INT1)D3
SW4
(INT0)D2
GND C1-C2
1uF 16V


VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC R4
SW1 220 LED1
1 AVCC
RST 15
D9
C1
0.1uF
VCC
Internal pull up
R2,R3
USB to UART (TTL Level) 1k R9-R12
DTR 3 220 x2 SW2
RXD D1(TXD) 11
2 D5
TXD D0(RXD)
+5V SW3
GND 6
3V3 D4
SW4
5
(INT1)D3
SW5
4
(INT0)D2
X1 C4-C5
16MHz 9 1uF 16V
XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมอ่านค่าข้อมูลจากหน่วยความจา EEPROM แอดเดรส 0-20 พร้อมทั้งเขียน
ข้อมูลเข้าไปใหม่โดยใช้สวิตช์ 2 ตัวในการตั้งค่าข้อมูลแล้วใช้สวิตช์ตวั ที่ 3 บันทึกข้อมูล
START
START
บันทึกค่ าข้อมูลลง EEPROM
อ่ านค่าข้ อมูลจาก EEPROM
เพิ่ม ค่าแอดเดรส 1 ค่ า
จริ ง
SW1 ูก กด? เพิ่ม ค่าข้ อมูล STOP
เท็จ
จริ ง ฟั งก์ชนั ่ ตอบสนองการอินเตอร์ ร ัพท์
SW2 ูก กด? ลดค่ า ข้อ มูล
เท็จ

1 #include <EEPROM.h>
2 #define interruptPin 2
3 #define IncValue 3
4 #define DecValue 4
5 volatile byte value;
6 volatile byte addr=0;
7 void setup()
8 {
10 pinMode(IncValue, INPUT_PULLUP);
11 pinMode(DecValue, INPUT_PULLUP);
12 pinMode(interruptPin, INPUT_PULLUP);
13 attachInterrupt(digitalPinToInterrupt(interruptPin), mem2eeprom, FALLING);
14 for(int i=0;i<=10;i++)
15 {
16 value = EEPROM.read(i);
17 Serial.print(i);
18 Serial.print("--->");
19 Serial.print(value);
20 Serial.println();
21 delay(100);
22 }
23 }
24 void loop()
25 {
26 if(digitalRead(IncValue)==LOW)
27 {
28 value++;
29 Serial.print("Data change to :");Serial.println(value);
30 }
31 else if(digitalRead(DecValue)==LOW)
32 {
33 value--;
34 Serial.print("Data change to :");Serial.println(value);
35 }
36 delay(150);
37 }
38 void mem2eeprom()
39 {
40 EEPROM.write(addr,value);
41 Serial.print("Write data ");Serial.print(value);
42 Serial.print(" to EEPROM address ");Serial.println(addr);
43 addr++;
44 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ EEPROM.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 กาหนดชื่อ interruptPin ให้แทน 2 (เป็ นขาที่สวิตช์ต่ออยูก่ บั ขา D2 ของ Arduino)
- บรรทัดที่ 3 กาหนดชื่อ IncValue ให้แทน 3 (เป็ นขาที่สวิตช์ต่ออยูก่ บั ขา D3 ของ Arduino)
- บรรทัดที่ 4 กาหนดชื่อ DecValue ให้แทน 4 (เป็ นขาที่สวิตช์ต่ออยูก่ บั ขา D4 ของ Arduino)
- บรรทัดที่ 5 ประกาศตัวแปรสาหรับเก็บข้อมูลของหน่วยความจา EEPROM
- บรรทัดที่ 6 ประกาศตัวแปรสาหรับเก็บแอดเดรสของหน่วยความจา EEPROM
- บรรทัดที่ 10-12 กาหนดโหมดให้กบั ขาพอร์ ตที่ต่อกับสวิตช์ทางานเป็ นอินพุทพอร์ ต
- บรรทัดที่ 13 ประกาศใช้งานอินเตอร์รัพท์จากขา D2(INT0)
- บรรทัดที่ 14-22 อ่านข้อมูลจากหน่วยความจา EEPROM แอดเดรส 0 ถึงแอดเดรสที่ 10 แล้วนา
ค่าที่อ่านได้มาแสดงผลหน้าจอคอมพิวเตอร์
- บรรทัด ที่ 26-30 ตรวจสอบถ้า สวิตช์ IncValue ถู ก กดให้ท าการเพิ่ มค่ าตัวแปร value ขึ้ น 1 ค่ า
พร้อมแสดงผลหน้าจอคอมพิวเตอร์
- บรรทัดที่ 31-35 ตรวจสอบถ้าสวิตช์ DecValue ถูกกดให้ทาการลดค่าตัวแปร value ลง 1 ค่าพร้อม
แสดงผลหน้าจอคอมพิวเตอร์
- บรรทัดที่ 38-44 ฟั งก์ชั่นตอบสนองการอิ นเตอร์ รัพท์ทาหน้าที่ บ นั ทึ กค่าจากตัวแปร value ลง
หน่วยความจา EEPROM
1. จาลองการทางานด้วยโปรแกรม Proteus เมื่อทาการจาลองการทางานที่มีการบันทึกข้อมูลลง
หน่วยความจา EEPROM แล้วกดหยุดการจาลองข้อมูลที่เคยบันทึกลงหน่วยความจาจะยังคง
อยู่ ดังนั้นเมื่อทาการจาลองใหม่ที่มีการอ่านข้อมูลจากหน่วยความจา EEPROM จะเป็ นข้อมูล
ที่ได้ถูกบันทึกไว้จากการจาลองครั้งที่ผา่ นมา และถ้าหากต้องการล้างข้อมูลใน EEPROM ให้
ดูเหมือนว่าเป็ นการทดลองครั้งแรกในซี พียใู หม่สามารถล้างข้อมูลใน EEPROM ได้โดยการ
คลิกที่ Reset Persistent Model data ดังรู ปที่ 4.15-5
3. สังเกตผลที่เกิดขึ้นจากการบันทึกข้อมูลลงในหน่วยความจา EEPROM
รู ปที่ 4.15-5 การล้างข้อมูลที่ถูกบันทึกไว้ใน EEPROM ของซีพียู

1. เขียนโปรแกรมอ่านข้อมู ลจากหน่ วยความจา EEPROM ทุ กแอดเดรสที่ มีขอ้ มู ลบันทึ กอยู่
(ข้ อ มู ล ในแอดเดรสที่ ไ ม่ ไ ด้ ถู ก บัน ทึ ก จะมี ค่ า เป็ น 255) และมี ก ารบัน ทึ ก ค่ า ใหม่ ล ง
หน่ วยความจา EEPROM โดยใช้สวิตช์ SW1, SW2 ในการตั้งค่า และการบันทึ กค่า ให้ใ ช้
สวิตช์ SW3 โดยให้ทางานด้วยวิธีอินเตอร์ รัพท์พร้ อมทั้งให้ LED ติดสว่างเมื่อมีการบันทึก
ข้อมู ลและดับเมื่ อบันทึ กข้อมู ลเสร็ จสิ้ น (ภายในฟั งก์ชั่นตอบสนองอิ นเตอร์ รัพท์ฟั ง ก์ชั่น
delay จะไม่สามารถใช้งานได้ให้ใช้วธิ ี อื่นแทน)
R1 LED1
220
D9
VCC
Internal pull up
R2-R4
220 x2 SW1
D5
SW2
D4
SW3
(INT1)D3
SW4
(INT0)D2
GND C1-C2
1uF 16V

2. เขียนโปรแกรมอ่านข้อมู ลจากหน่ วยความจา EEPROM ทุ กแอดเดรสที่ มีขอ้ มู ลบันทึ กอยู่

(ข้อมูลในแอดเดรสที่ไม่ได้ถูกบันทึกจะมีค่าเป็ น 255) และมีการบันทึกค่าใหม่ที่เป็ นตัวแปร
ทศนิยม (float) ลงหน่วยความจา EEPROM โดยใช้สวิตช์ SW1 ตั้งค่าเลขที่มากว่า 0 ใช้สวิตช์
SW2 ตั้งค่าทศนิ ยมหลักที่ 1 SW3 ตั้งค่าทศนิ ยมหลักที่ 2 (ใช้ทศนิ ยม 2 หลัก) การบันทึกค่า
ให้ใช้สวิตช์ SW4 โดยให้ทางานด้วยวิธีอินเตอร์ รัพท์พร้ อมทั้งให้ LED ติดสว่างเมื่อมี การ
บันทึ ก ข้อมู ล และดับ เมื่ อบันทึ ก ข้อมู ล เสร็ จสิ้ น (ภายในฟั ง ก์ชั่นตอบสนองอิ นเตอร์ รัพ ท์
ฟังก์ชนั่ delay จะไม่สามารถใช้งานได้ให้ใช้วธิ ี อื่นแทน)
R1 LED1
220
D9
VCC
Internal pull up
R2-R4
220 x2 SW1
D5
SW2
D4
SW3
(INT1)D3
SW4
(INT0)D2
GND C1-C2
1uF 16V

ใบงานที่ 4.16 การเขียนโปรแกรมใช้งานคียแ์ พด  203
การเขียนโปรแกรมใช้ งานคีย์แพด
เพื่อให้สามารถเขียนโปรแกรมใช้งานคียแ์ พดได้
1. บอกวิธีเขียนโปรแกรมใช้งานคียแ์ พดได้
4. คียแ์ พดขนาด 3×4 1 ตัว
การใช้งานสวิตช์ของไมโครคอนโทรลเลอร์ ไม่วา่ จะเป็ นในตระกูลใดสามารถใช้งานได้โดยการ
ต่อเข้ากับพอร์ ต 1 บิตต่อสวิตช์ 1 ตัวซึ่ งการต่อลักษณะนี้ เหมาะสาหรับวงจรที่ใช้สวิตช์จานวนน้อยแต่ถา้
หากต้องการใช้งานสวิตช์จานวนมากจะทาให้เหลือพอร์ ตที่ ไปใช้งานอย่างอื่นลดลง ตัวอย่างเช่นต้องการ
ต่อสวิตช์จานวน 12 ตัวกับพอร์ ตดิจิทลั ของ Arduino UNO หรื อ Nano ที่มีพอร์ตดิจิทลั ใช้งานเพียง 14 บิต
(หากมีการสื่ อสารผ่านพอร์ อนุกรมจะเหลือเพียง 12 ตัว) จะไม่เหลือพอร์ ตเอาไปใช้งานอื่นได้เลยดังรู ป
D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13
1 2 3 4 5 6 7 8 9 0 * #
รู ปที่ 4.16-1 การต่อสวิตช์แบบทัว่ ไปกับพอร์ ตดิจิทลั
วิธี ก ารลดขนาดของพอร์ ตใช้ง านโดยสามารถต่ อสวิตช์ ไ ด้จานวนมากคื อการต่ อสวิตช์แบบ

เมตริ กเช่ นต้องการต่อสวิตช์จานวน 16 ตัวสามารถจัดวางแบบ 4×4 ซึ่ งใช้พอร์ ตเพียง 8 บิตหรื อต้องการ
ต่อสวิตช์จานวน 12 ตัวสามารถจัดวางแบบ 3×4 ซึ่ งใช้พอร์ ตเพียง 7 บิตทาให้ลดขนาดของพอร์ ตใช้งาน
ได้การต่อสวิตช์เป็ นดังรู ป 4.16-2
D12 1
1 2 3
D11 2
row pinouts
4 5 6
D10 3
7 8 9
D9 4
* 0 #
5 6 7
D8 D7 D6
column pinouts
รู ปที่ 4.16-2 การต่อสวิตช์ 12 ตัวต่อแบบเมตริ ก 3×4
การใช้งานจะต้องเขียนโปรแกรมให้พอร์ ตด้านใดด้านหนึ่ งเป็ นอิ นพุทพอร์ ตส่ วนอีกด้านเป็ น

เอาท์พุต โดยวิธีเขียนโปรแกรมตรวจสอบการกดคียใ์ ช้วิธีการสั่งให้พอร์ ตที่เชื่ อมต่อเป็ นสวิตช์ดา้ นที่เป็ น
เอาท์พุทให้มีค่าลอจิก 0 (เสมือนต่อลงกราวด์) ช่วงเวลาละ 1 บิตแล้วตรวจสอบการกดสวิตช์จากพอร์ ตที่
เชื่อมต่อด้านที่เป็ นอินพุทว่ามีการเปลี่ยนแปลงในบิตใดตรงกับหมายเลยสวิตช์ใดดังรู ป 4.16-3
0 1 1 1 1 1
1 2 3 1 2 3 1 2 3
Logic to Input Port
Logic to Input Port
Logic to Input Port

1 2 0 2 1 2
4 5 6 4 5 6 4 5 6
1 3 1 3 0 3
7 8 9 7 8 9 7 8 9
1 4 1 4 1 4
* 0 # * 0 # * 0 #
5 6 7 5 6 7 5 6 7
0 1 1 0 1 1 0 1 1
Logic from Output Port Logic from Output Port Logic from Output Port
รู ปที่ 4.16-3 ตัวอย่างค่าที่อ่านได้จากการกดสวิตช์เมื่อให้ขา 5 เป็ นลอจิก 0
ตารางที่ 4.16-1 ค่าที่อ่านได้จากการกดสวิตช์ในแต่ละตัว

ค่าที่ส่งออกพอร์ ตเอาท์พุทไป เมื่อกดสวิตช์หมายเลข ค่าที่รับได้จากพอร์ ตอินพุท
ยังสวิตช์ดา้ น Colum ขา 5,6,7 ที่ต่อด้าน Row ขา 1,2,3,4
1 0111
4 1011
011 7 1101
* 1110
2 0111
5 1011
101
8 1101
0 1110
3 0111
6 1011
110
9 1101
# 1110
ปั จจุบนั มีคียแ์ พดสาเร็ จรู ปมาให้ใช้งานโดยผูใ้ ช้งานไม่ตอ้ งออกแบบวงจรเองทาให้สะดวกมาก

ยิ่งขึ้น คียแ์ พดที่นิยมนามาใช้งานมีการจัดเรี ยงขาโดย 4 ขาแรกเป็ นด้าน Row อีก 3 ขาที่เหลือเป็ นด้าน
Colum ดังรู ป 4.16-4
1 2 3 1 2 3
4 5 6 4 5 6
7 8 9 7 8 9
* 0 # * 0 #
1 2 3 4 5 6 7
1 7
รู ปที่ 4.16-4 คียแ์ พดขนาด 3×4 และการจัดเรี ยงขา

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

สามารถเขียนโค้ดได้ง่ายขึ้นสามารถดาวน์โหลดได้ที่
Keypad.h https://github.com/Chris--A/Keypad

รู ปที่ 4.16-5 การดาวน์โหลดไลบรารี่

รู ปที่ 4.16-6 การเพิ่มไลบรารี่ ที่เป็ นไฟล์ zip ลงในโปรแกรม Arduino IDE
6. ฟังก์ชั่น Arduino ทีใ่ ช้ ในใบงาน

1. ฟั งก์ ชั่นกาหนดโหมดการทางานให้ กับขาพอร์ ต โดยสามารถกาหนดได้ท้ งั ขาดิจิทลั โดยใส่
pinMode(pin, mode);
value: HIGH or LOW

delay(ms);
4. ฟั งก์ ชั่นกาหนดความเร็ วในการสื่ อสารทางพอร์ ตอนุ กรม เพื่อให้สามารถสื่ อสารระหว่าง

อุ ปกรณ์ ท้ งั สองฝั่ งได้จะต้องกาหนดอัตราเร็ วในการสื่ อสารหรื อเรี ยกว่าอัตราบอด (Baud
rate) ค่าความเร็ วนี้ มีหน่ วยเป็ นบิตต่อวินาที (bps: bit per second) ค่าความเร็ วนี้ ได้แก่ 300,
600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, หรื อ 115200
5. ฟังก์ชั่นส่ งข้ อมูลออกพอร์ ต เป็ นฟังก์ชนั่ ที่ใช้ในการส่ งข้อมูลออกทางพอร์ ตอนุกรมหรื ออาจ

เรี ยกว่าฟั งก์ชนั่ พิมพ์ขอ้ มูลออกทางพอร์ ตเพื่อแสดงผลที่จอคอมพิวเตอร์ ที่เชื่ อมต่อกับวงจร
Arduino โดยฟังก์ชนั่ นี้เมื่อพิมพ์เสร็ จตัวเคอร์ เซอร์ จะรออยูท่ ี่ทา้ ยสิ่ งที่พิมพ์น้ นั ๆ
ฟังก์ชั่นใช้ งานของไลบรารี่ Keypad

การอ่านค่าจากสวิตช์ Keypad หากใช้ไลบรารี่ ช่วยงานจะทาให้การเขียนโค้ดง่ายขึ้นเป็ นอย่างมาก
ซึ่ งไลบรารี่ ไม่ได้ถูกเพิ่มเข้ามาในตัวโปรแกรม Arduino IDE ตั้งแต่แรกจาเป็ นต้องติดตั้งเพิ่มเติม โดยมี
การตั้งค่าและฟังก์ชนั่ ให้ใช้งานดังนี้
1. การกาหนดขนาดของสวิตช์ คีย์แพด ไลบรารี่ เลื อกใช้วิธีการกาหนดขนาดคียแ์ พดที่ใช้งาน

ด้วยวิธีประกาศตัวแปร ยกตัวอย่างเช่นต้องการใช้คียแ์ พดขนาด 3×4 การกาหนดขนาดเป็ น
ดังนี้
const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
2. การกาหนดค่ าทีไ่ ด้ เมื่อกดคีย์ตาแหน่ งต่ าง ๆ รู ปแบบเป็ นดังนี้

char keys[ROWS][COLS] = {
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
3. การกาหนดขาพอร์ ตทีเ่ ชื่ อมต่ อกับคีย์แพด รู ปแบบเป็ นดังนี้

byte rowPins[ROWS] = {5, 4, 3, 2}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {8, 7, 6}; //connect to the column pinouts of the keypad
4. การกาหนดค่ าเริ่มใช้ งาน รู ปแบบเป็ นดังนี้

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
5. ฟังก์ชั่นอ่านค่ าการกดสวิตช์ คีย์แพด เป็ นฟังก์ชนั่ ที่ใช้อ่านค่าการกดสวิตช์คียแ์ พดโดยค่าที่ได้

จากฟั งก์ชนั่ จะมีค่าเป็ น 0 เมื่อไม่มีการกดคียใ์ ด ๆ แต่ถา้ หากมีการกดคียใ์ นตาแหน่งใดจะให้
ค่าได้จากการกาหนดค่าในตัวแปร char keys[ROWS][COLS] ข้างต้นที่ได้กล่าวมาแล้ว
.getKey();

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC 1 2 3
RST
C1 4 5 6
0.1uF
D12 18
7 8 9
D11 17 * 0 #
USB to UART (TTL Level)
R2,R3 D10 16
1k
DTR 3 D9 15
RXD D1(TXD)
2
TXD D0(RXD) D8 14
+5V
GND D7 13
3V3
D6 12
X1
16MHz 9 XTAL1 R4 LED1
220
10 XTAL2 11
D5
C2,C3 GND
22pF 8,22

ARDUINO
1 2 3
4 5 6
7 8 9
D12
D11 * 0 #
D10
D9
D8
D7
D6
R1 LED1
220
D5
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
D13
3V3
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1
การทดลองที่ 1 เขียนโปรแกรมอ่านค่าข้อมูลจากหน่วยความจา EEPROM แอดเดรส 0-20 พร้อมทั้งเขียน
ข้อมูลเข้าไปใหม่โดยใช้สวิตช์ 2 ตัวในการตั้งค่าข้อมูลแล้วใช้สวิตช์ตวั ที่ 3 บันทึกข้อมูล

START
กาหนดค่าเริ ่มต้ นต่ าง ๆ
อ่ านค่าจากคีย์แพด
เท็จ
มีการกดคีย์?
จริ ง
แสดง ลคีย์ท่ ี ู กกด
สั ่ง LED กระพริบ 1 ครั้ง
แปลง งั งานเป็ นโปรแกรม จากผังงานสามารถเขียนเป็ นโค้ดโปรแกรมควบคุม Arduino

1 #include <Keypad.h>
2 #define LED 5
3 const byte ROWS = 4; //four rows
4 const byte COLS = 3; //three columns
5 char keys[ROWS][COLS] = {
6 {'1','2','3'},
7 {'4','5','6'},
8 {'7','8','9'},
9 {'*','0','#'}
10 };
11 byte rowPins[ROWS] = {12,11,10,9}; //connect to the row pinouts of keypad
12 byte colPins[COLS] = {8,7,6}; //connect to the column pinouts of keypad
13 Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
14 void setup()
15 {
18 }
19 void loop()
20 {
21 char key = keypad.getKey();
22 if (key)
23 {
24 Serial.println(key);
25 digitalWrite(LED,HIGH);delay(200);
27 }
28 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ Keypad.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 กาหนดชื่อ LED ให้แทน 5 (เป็ นขา LED ต่ออยูก่ บั ขา D5 ของ Arduino)
- บรรทัดที่ 3 กาหนดจานวนขาต่อคียแ์ พดด้าน Row
- บรรทัดที่ 4 กาหนดจานวนขาต่อคียแ์ พดด้าน Colum
- บรรทัดที่ 5 กาหนดค่าที่ได้จากการกดคียแ์ พดในแต่ละตาแหน่ง
- บรรทัดที่ 11 กาหนดขาพอร์ ตที่ใช้เชื่อมต่อกับคียแ์ พดด้าน Row

- บรรทัดที่ 12 กาหนดขาพอร์ ตที่ใช้เชื่อมต่อกับคียแ์ พดด้าน Colum
- บรรทัดที่ 13 ประกาศเริ่ มใช้งานไลบรารี่ คียแ์ พด
- บรรทัดที่ 17 กาหนดโหมดให้กบั ขาพอร์ ตที่ต่อกับ LED ทางานเป็ นเอาท์พุทพอร์ต
- บรรทัดที่ 21 อ่านค่าการกดคียแ์ พด
- บรรทัดที่ 22 ตรวจสอบถ้ามีการกดคียใ์ ด ๆ ที่คียแ์ พด
- บรรทัดที่ 24 แสดงค่าคียท์ ี่ถูดกดบนจอคอมพิวเตอร์ ผา่ นการสื่ อสารทางพอร์ ตอนุกรม
- บรรทัดที่ 25 สั่งให้ LED ติดสว่างเป็ นเวลา 200 มิลลิวนิ าที (1/5 วินาที)
- บรรทัดที่ 26 สั่งให้ LED ดับ
9. สรุป ลการปฏิบัติงาน

เขียนโปรแกรมรับค่าจากคียแ์ พดให้เก็บลงในตัวแปรเป็ นตัวเลข 2 หลัก (0-99) พร้อมทั้งแสดงผล
ค่าตัวแปรผ่านทางจอคอมพิวเตอร์ โดยการกดสวิตช์ครั้งแรกให้ตวั เลขเป็ นค่าหลักหน่วยและเมื่อกดครั้งที่
สองตัวเลขแรกจะกลายเป็ นเลขหลักสิ บส่ วนตัวเลขที่กดใหม่จะเป็ นตัวเลขหลักหน่วยแทนเมื่อกดครั้งที่
สามเลขหลักสิ บจะหายไปเลขหลักหน่วยให้ขยับเป็ นเลขหลักสิ บและให้ตวั เลขที่กดใหม่เป็ นหลักหน่วย
แทนเวียนเช่นนี้ไปเรื่ อย ๆ วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
1 2 3
4 5 6
7 8 9
D12
D11 * 0 #
D10
D9
D8
D7
D6
R1 LED1
220
D5
GND
รู ปที่ 4.16-11 วงจรทดลองสาหรับงานที่มอบหมาย

ใบงานที่ 4.17 การเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ 4 บิต  213
การเขียนโปรแกรมแสดงผลด้ วยจอ LCD ทีเ่ ชื่ อมต่ อแบบ 4 บิต
เพื่อให้สามารถเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ 4 บิตได้
1. บอกวิธีเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ 4 บิตได้
2.1 ตัวท้านทานปรับค่าได้ขนาด 10k 1 ตัว
4. LCD ชนิดตัวอักษรขนาด 16x2 1 ตัว
อุปกรณ์ แสดงผลของเครื่ องใช้ไฟฟ้ าหรื อเครื่ องใช้ที่เป็ นอิเล็กทรอนิ กส์ ในปั จจุบนั จะเลือกใช้
LCD ในการแสดงผลเป็ นส่ วนใหญ่ เช่ น เครื่ องคิดเลข นาฬิ กา เครื่ องมือวัดแบบตัวเลขและอื่นๆ อีก
มากมาย LCD ย่อมาจากคาว่า Liquid Crystal Display เป็ นอุปกรณ์แสดงผลที่กินไฟน้อยมากเป็ นอุปกรณ์
ที่แสดงผลโดยไม่ได้อาศัยการเปล่งแสงที่ตวั เองแต่ใช้วิธีการปิ ดบังแสงไม่ให้สะท้อนให้หรื อไม่ให้ส่อง
ผ่านแทน ซึ่ง LCD สามารถแบ่งได้ 3 แบบคือ
1. Segment display ชนิด LCD module
2. Character LCD module
3. Graphic LCD module
ส่ วนประกอบหลักของจอผลึกเหลว (LCD) ภายในประกอบด้วยส่ วนหลัก 3 ส่ วนด้วยกันคือ
1. ตัวแสดงผล (Display) เป็ นตัวแสดงผลให้เราได้มองเห็น ในลักษณะการปิ ดและเปิ ดกับแสง
ก็คือส่ วนที่เป็ นตัวกระจกบรรจุผลึกเหลว
2. ตัวขับ (Driver) เป็ นตัวรับสัญญาณจากตัวควบคุมมาขับให้ตวั แสดงผลแสดงข้อมูล ตามที่
กาหนด
3. ตัวควบคุม (Controller) เป็ นตัวรับข้อมูลจากอุปกรณ์ภายนอก มาควบคุมการทางานของตัว
LCD Module เบอร์ที่นิยมใช้คือ
- HD4478 ใช้ควบคุม Character LCD module
- HD61830ใช้ควบคุม Graphic LCD module
การต่ อใช้ งาน ใบงานนี้ เป็ นการทดลองการใช้งาน LCD ชนิ ดตัวอักษร ซึ่ งการต่อใช้งานตาม
คุ ณสมบัติข องโมดู ลสามารถเชื่ อมต่ อให้มีก ารสื่ อสารข้อมู ลได้ 2 แบบคื อ แบบ 8 บิ ตและแบบ 4 บิ ต
สาหรับการทดลองเพื่อใช้งาน LCD ด้วย Arduino ใช้การเชื่อมต่อแบบ 4 บิตเนื่องจากพอร์ ตของ Arduino
มีจากัด สาหรับขนาดของ LCD ชนิ ดตัวอักษรมีให้เลือกใช้หลายขนาดผูใ้ ช้งานสามารถเลือกใช้ได้ตาม
ต้องการโดยมีขนาดให้เลือกตามตาราง
ตารางที่ 4.17-1
จานวนตัวอักษรต่อแถว 8 ตัวอักษร 16 ตัวอักษร 20 ตัวอักษร 40 ตัวอักษร
ขนาดของ LCD ที่มีให้ใช้งาน 8×2 16×1 20×1 40×1
16×2 20×2 40×2
16×4 20×4 40×4

1. ฟั งก์ ชั่ นหน่ ว งเวลา หรื อฟั ง ก์ชั่นหยุดค้า ง การใช้ง านสามารถก าหนดตัว เลขของเวลาที่
delay(ms);
2. ฟั งก์ ชั่นส่ งค่ าเวลาตั้งแต่ บอร์ ดเริ่ มทางาน ตัวเลขที่ส่งกลับมาจากฟั งก์ชนั่ เป็ นเลขของเวลา
ตั้งแต่บอร์ ดเริ่ มทางานมีหน่ วยเป็ นมิ ลลิ วินาที ซึ่ งตัวเลขจะวนกลับเป็ นศูนย์อีกครั้ ง (Over
Flow) เมื่อเวลาผ่านไปประมาณ 50 วันหลังจากบอร์ ดเริ่ มทางาน รู ปฟังชัน่ เป็ นดังนี้
millis();
unsigned long time=millis();
หมายถึง เก็บค่าเวลาตั้งแต่บอร์ ดเริ่ มทางานโดยเก็บค่าลงในตัวแปร time
ฟังก์ชั่นใช้ งานของไลบรารี่ LCD

การใช้งานแสดงผลที่ LCD ชนิดตัวอักษรจาเป็ นต้องใช้ไลบรารี่ ช่วยงาน ซึ่ งไลบรารี่ ถูกเพิ่มเข้ามา
ในตัวโปรแกรม Arduino IDE แล้วไม่ตอ้ งติดตั้งเพิ่มเติม
LiquidCrystal.h ไม่ตอ้ งดาวน์โหลดเนื่องจากมาพร้อมกับ Arduino IDE
มีฟังก์ชนั่ ให้ใช้งานดังนี้
1. ฟังก์ ชั่นกาหนดขาเชื่ อมต่ อ ใช้ในการระบุขาที่ใช้เชื่ อมต่อให้ตวั โปรแกรมรับรู ้ การเชื่ อมต่อ
จะใช้การสื่ อสารแบบ 4 บิตฟังชัน่ นี้เป็ นการกาหนดค่าในส่ วนหัวโปรแกรม รู ปแบบเป็ นดังนี้
LiquidCrystal lcd_name(RS, EN, D4, D5, D6, D7);
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);
หมายถึง ต่อไปในโปรแกรมจะใช้ชื่อ lcd ในการเรี ยกใช้งานโดยมีการเชื่ อมต่อสายสัญญาณ ดัง
ในวงเล็บโดยตัวเลขแรกเป็ นขา RS ไล่ไปจนตัวเลขสุ ดท้ายเป็ นขา D7 ซึ่ งเป็ นชื่อทั้งหมดเป็ นชื่ อ
ขาของ LCD
2. ฟังก์ชั่นกาหนดขนาดของ LCD ใช้กาหนดขนาดของ LCD ที่กาลังเชื่อมต่อ รู ปแบบเป็ นดังนี้

.begin(cols, rows);
cols: ตัวเลขจานวนตัวอักษรต่อหนึ่งบรรทัด
rows: ตัวเลขจานวนบรรทัดของจอ LCD
ตัวอย่าง lcd.begin(16, 2); หมายถึง ใช้ LCD ขนาด 16 ตัวอักษร 2 บรรทัด
3. ฟังก์ชั่นแสดงผลออกจอ LCD ใช้แสดงข้อความ ตัวเลข หรื อค่าในตัวแปร รู ปแบบเป็ นดังนี้

.print(data);
.print(data, BASE);
data: คือข้อมูลที่ตอ้ งการแสดงผลซึ่ งอาจเป็ นข้อความ ตัวเลข หรื อค่าในตัวแปร
โดยถ้าเป็ นข้อความจะต้องใส่ “-” คร่ อมข้อความนั้น ๆ
BASE: รู ปแบบการแสดงผลของค่าตัวเลข (เลขฐาน) ได้แก่ BIN,DEC,OCT,HEX
4. ฟั งก์ ชั่นล้ างหน้ าจอ ใช้ลา้ งข้อมูลบนหน้าจอแล้วให้เคอร์ เซอร์ กลับไปรอที่ตาแหน่ งมุมบน

ซ้ายของจอ รู ปแบบเป็ นดังนี้
.clear();
5. ฟั งก์ ชั่นกาหนดตาแหน่ งเคอร์ เซอร์ ก่อนการพิมพ์ ใช้กาหนดพิกดั ให้เคอร์ เซอร์ ไปรอก่ อน

การแสดงผลในฟังก์ชนั่ lcd.print() รู ปแบบเป็ นดังนี้
.setCursor(col, row);
col: ตาแหน่งของคอลัมน์ที่เคอร์ เซอร์ ตอ้ งไปรอ (คอลัมน์แรกคือ 0)
row: ตาแหน่งของบรรทัดที่เคอร์ เซอร์ ตอ้ งไปรอ (บรรทัดแรกคือ 0)
ตัวอย่าง lcd.setCursor (6, 1); หมายถึง ให้เคอร์ เซอร์ ไปรอที่ตาแหน่งคอลัมน์ 6 บรรทัด 1

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1 4 11
D2 D4
0.1uF 5 12
D3 D5
6 13
D4 D6
11 14
D5 D7
R2,R3
DTR 3 E R/W RS Vo VCC GND
RXD D1(TXD)
2 12 6 5 4 3 2 1
TXD D0(RXD) D6
+5V VCC
GND 13
3V3 D7
10k
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
11
5V D2 D4
12
D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1


การทดลองที่ 1 เขียนโปรแกรมแสดงข้อความ “hello, world!”
START
แสดงผล

1 #include <LiquidCrystal.h>
2 /* The circuit:
3 * LCD RS pin to digital pin 7
4 * LCD E pin to digital pin 6
5 * LCD D4 pin to digital pin 2
9 * LCD R/W pin to ground
10 */
11 LiquidCrystal lcd(7,6,2,3,4,5); // set up the LCD's connection pins
12 void setup()
13 {
14 lcd.begin(16, 2); // set LCD size
15 lcd.print("hello, world!");
16 }
17 void loop() {}
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ LiquidCrystal.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2-10 เป็ นส่ วนอธิ บายว่าขาใดของ LCD เชื่อมต่อกับขาใดของ Arduino
- บรรทัดที่ 11 กาหนดจานวนขาพอร์ ตที่ใช้เชื่อมต่อกับ LCD

- บรรทัดที่ 14 ประกาศเริ่ มใช้งานไลบรารี่ LCD พร้อมกาหนดขนาดของ LCD
- บรรทัดที่ 15 แสดงข้อความบนหน้าจอ LCD
3. ทดลองเปลี่ยนรู ปแบบการแสดงผล
การทดลองที่ 2 เขียนโปรแกรมแสดงเวลาที่บอร์ ดเริ่ มทางาน โดยแสดงเวลาหน่วยเป็ นวินาทีแสดงผลด้วย

จอ LCD
START
อ่ านค่าเวลาจากบอร์ ด
แสดงผล

2 /* The circuit:
10 */
12 void setup()
13 {
15 lcd.print("Running time");
16 lcd.setCursor(13,1);
17 lcd.print("sec");
18 }
19 void loop()
20 {
22 lcd.print(millis()/1000);
23 delay(1000);
24 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ LiquidCrystal.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2-10 เป็ นส่ วนอธิ บายว่าขาใดของ LCD เชื่อมต่อกับขาใดของ Arduino
- บรรทัดที่ 11 กาหนดจานวนขาพอร์ ตที่ใช้เชื่อมต่อกับ LCD
- บรรทัดที่ 14 ประกาศเริ่ มใช้งานไลบรารี่ LCD พร้อมกาหนดขนาดของ LCD
- บรรทัดที่ 15 แสดงข้อความบนหน้าจอ LCD "Running time"
- บรรทัดที่ 16 ขยับเคอร์ เซอร์ ไปยังตาแหน่งที่ระบุ
- บรรทัดที่ 22 แสดงข้อมูลที่เกิดจากการคานวนค่าเวลาบนหน้าจอ LCD
3. ทดลองเปลี่ยนแปลงรู ปแบบการแสดงผล

1. เขียนโปรแกรมแสดงผลให้คล้ายลักษณะไฟวิ่งโดยใช้ * แทนไฟ กาหนดรู ปแบบของการวิง่
ตามความต้อ งการแสดงผลในบรรทัด ล่ า ง ส าหรั บ บรรทัด บนให้ แสดงข้อ ความค้า งไว้
ข้อความว่า “Light Running” วงจรที่ใช้ทดลองเป็ นดังรู ป
VCC ARDUINO
11
5V D2 D4
12
D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
GND

ใบงานที่ 4.18 การเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ I2C  221
การเขียนโปรแกรมแสดงผลด้ วยจอ LCD ทีเ่ ชื่ อมต่ อแบบ I2C
เพื่อให้สามารถเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ I2C ได้
1. บอกวิธีเขียนโปรแกรมแสดงผลด้วยจอ LCD ที่เชื่อมต่อแบบ I2C ได้
3. LCD ชนิดตัวอักษรขนาด 16x2 1 ตัว
4. โมดูลสื่ อสาร I2C สาหรับ LCD 1 ตัว
I2C Bus ย่อ มาจาก Inter Integrate Circuit Bus (IIC) (ออกเสี ย งว่า ไอ-แสคว-ซี - บัส ) เป็ นการ
สื่ อสารอนุกรม แบบซิ งโครนัส (Synchronous) เพื่อใช้ ติดต่อสื่ อสาร ระหว่าง ไมโครคอนโทรลเลอร์ กบั
อุปกรณ์ต่อพ่วงภายนอกใช้สายสัญญาณสื่ อสาร 2 เส้นคือ Serial data (SDA) และ Serial clock (SCL) ซึ่ ง
สามารถเชื่อมต่ออุปกรณ์จานวนหลาย ๆ ตัว เข้าด้วยกันโดยใช้ขาพอร์ตเพียง 2 ขาเท่านั้น
VDD
Rpullup
SCL
SDA
Master Slave #1 Slave #2 Slave #n
รู ปที่ 4.18-1 ผังการต่อเชื่อมระหว่างไมโครคอนโทรลเลอร์ กบั อุปกรณ์ I2C
วิธีการที่จะเลือกสื่ อสารกับอุปกรณ์ต่อพ่วงใช้การควบคุมที่ไบต์ของรหัสควบคุม (Control byte)

ประกอบด้วยรหัสประจาตัวอุปกรณ์ (Device ID) เป็ นรหัสที่เปลี่ยนแปลงไม่ได้ และรหัสที่เป็ นแอดเดรส
ของตัว อุ ป กรณ์ ซ่ ึ งผู ้ใ ช้ ง านสามารถก าหนดได้ โ ดยมี แ อดเดรสจ านวน 3 ขาคื อ A0, A1, A2 นั่ น ก็
หมายความว่า หากต่ อพ่วงอุ ป กรณ์ I2C ที่ เป็ นชนิ ดเดี ย วกันมี รหัส ประจาตัวเดี ย วกันสามารถก าหนด
แอดเดรสต่างกันได้ 8 ตัวซึ่งหมายถึงสามารถต่อพ่วงอุปกรณ์ชนิดเดียวกันได้ 8 ตัว
ID ID ID ID A2 A1 A0 R/W
Device ID Address Mode

Control byte
รู ปที่ 4.18-2 คอนโทรลไบต์ของอุปกรณ์ I2C
การใช้งานจอแสดงผล LCD ที่ใช้การสื่ อสารแบบ I2C ตัวอุปกรณ์จริ งเป็ นการใช้ LCD ธรรมดา
เช่นเดียวกับใบงานที่ผา่ นมาเพียงแต่เพิ่มโมดูลสื่ อสารแบบ I2C เสี ยบเพิ่มเข้าที่ตวั จอ หากไม่ได้แก้ไขใด ๆ
ที่ตวั โมดู ล ขาแอดเดรสของโมดู ลจะไม่ได้ถูกชอร์ ตลงกราวด์ดงั นั้นขาแอดเดรสทั้ง 3 ขาจะเป็ นลอจิก
HIGH ทั้งหมดดังรู ป
รู ปที่ 4.18-3 โมดูลสื่ อสารแบบ I2C สาหรับขับจอ LCD

รู ปที่ 4.18-4 โมดูลสื่ อสารแบบ I2C เมื่อเชื่ อต่อกับจอ LCD
แอดแดรสของโมดู ลสามารถแก้ไขเป็ นตาแหน่ งอื่ นได้โดยการบัดกรี เชื่ อมต่อให้ถึงกัน (Low)

หรื อปลดลอย (High) เพื่อกาหนดแอดเดรส (A0 A1 A2) ที่ตวั โมดู ลโดยสามารถกาหนดแอดเดรสเป็ น
ตาแหน่ ง อื่ นได้ หมายเลขของแอดเดรส (รวมรหัส ประจาตัว ) ของโมดู ล ที่ ใ ช้ชิ พ เบอร์ ต่า งกัน จะได้
แอดเดรสที่ ต่างกัน ดังนั้นหากโมดู ลที่ใช้ชิพเบอร์ PCF8574 แอดเดรสจะเป็ น 27H และเมื่อใช้ชิพเบอร์
PCF8574A แอดเดรสจะเป็ น 3FH (กรณี ที่ไม่ได้บดั กรี แก้ไขแอดเดรส)
รู ปที่ 4.18-5 แอดเดรสของโมดูลสื่ อสารแบบ I2C สาหรับจอ LCD ที่สามารถแก้ไขได้
การเขี ย นโค้ด โปรแกรมเพื่ อ ใช้ง านการแสดงผลจอ LCD ที่ สื่ อ สารด้ว ยโมดู ล สื่ อ สาร I2C
จาเป็ นต้องใช้ไลบรารี่ ช่วยงานพร้อม ๆ กันถึงสองตัวดังนี้
- Wire.h มีมาพร้อมกับโปรแกรม Arduino IDE
- LiquidCrystal_I2C.h ต้องดาวน์โหลดเพิ่ม เติ ม เนื่ องจากโปรแกรม Arduino IDE ไม่ได้มีก าร
ติดตั้งมาให้ต้ งั แต่เริ่ มต้น
Wire.h ไม่ตอ้ งดาวน์โหลดเนื่องจากมาพร้อมกับ Arduino IDE
LiquidCrystal_I2C.h https://github.com/marcoschwartz/LiquidCrystal_I2C
การติดตั้งไลบรารี่ มีข้ นั ตอนการดาเนินการเพื่อนาไลบรารี่ มาใช้งานดังนี้


2. ทาการเพิ่มไลบรารี่ ลงในโปรแกรม Arduino IDE โดยการเพิ่มจากไฟล์ zip แล้วทาการหาไฟล์
zip ที่ได้จากการดาวน์โหลดในข้อ 1
รู ปที่ 4.18-7 การเพิ่มไลบรารี่ ลงในโปรแกรม Arduino IDE

delay(ms);
Flow) เมื่อเวลาผ่านไปประมาณ 50 วันหลังจากบอร์ ดเริ่ มทางาน รู ปฟังชัน่ เป็ นดังนี้
millis();
ฟังก์ชั่นใช้ งานของไลบรารี่ LCD I2C

การใช้งานแสดงผลที่ LCD ที่สื่อสารด้วยโมดูล I2C มีฟังก์ชนั่ การใช้งานคล้าย ๆ กับการใช้ LCD
ธรรมดาเช่นเดียวกับใบงานที่ผา่ นมาได้แก่
1. ฟังก์ชั่นกาหนดแอดเดรสและขนาดของ LCD ใช้ในการระบุแอดเดรสของโมดูลสื่ อสาร I2C
ที่เชื่อมต่อกับ LCD และขนาดของจอ LCD ที่ใช้งาน รู ปแบบเป็ นดังนี้
LiquidCrystal_I2C lcd_name(address,col,row);
address: แอดเดรสของโมดูล I2C
cols: จานวนตัวอักษรต่อหนึ่งบรรทัดของจอ LCD
rows: จานวนบรรทัดของจอ LCD
ตัวอย่าง LiquidCrystal_I2C lcd(0x3F,16,2);
หมายถึง ต่ อ ไปในโปรแกรมจะใช้ ชื่ อ lcd ในการเรี ย กใช้ง านโดยโมดู ล เชื่ อ มต่ อ มี
แอดเดรสเป็ น 3FH และเป็ นจอ LCD ขนาด 16 ตัวอักษร 2 บรรทัด
2. ฟังก์ชั่นกาหนดขนาดของ LCD ใช้กาหนดขนาดของ LCD ที่กาลังเชื่อมต่อ รู ปแบบเป็ นดังนี้

.begin(cols, rows)
cols: ตัวเลขจานวนตัวอักษรต่อหนึ่งบรรทัด
rows: ตัวเลขจานวนบรรทัดของจอ LCD
ตัวอย่าง lcd.begin(16, 2);
หมายถึง ใช้ LCD ขนาด 16 ตัวอักษร 2 บรรทัด
3. ฟังก์ชั่นแสดงผลออกจอ LCD ใช้แสดงข้อความ ตัวเลข หรื อค่าในตัวแปร รู ปแบบเป็ นดังนี้

.print(data);
.print(data, BASE);
data: คือข้อมูลที่ตอ้ งการแสดงผลซึ่ งอาจเป็ นข้อความ ตัวเลข หรื อค่าในตัวแปร
โดยถ้าเป็ นข้อความจะต้องใส่ “-” คร่ อมข้อความนั้น ๆ
BASE: รู ปแบบการแสดงผลของค่าตัวเลข (เลขฐาน) ได้แก่ BIN,DEC,OCT,HEX
4. ฟังก์ ชั่นล้ างหน้ าจอ ใช้ลา้ งหน้าจอแล้วให้เคอร์ เซอร์ กลับไปรอที่ตาแหน่งมุมบนซ้ายของจอ

.clear();
5. ฟั งก์ ชั่นกาหนดตาแหน่ งเคอร์ เซอร์ ก่อนการพิมพ์ ใช้กาหนดพิกดั ให้เคอร์ เซอร์ ไปรอก่ อน

การแสดงผลในฟังก์ชนั่ lcd.print() รู ปแบบเป็ นดังนี้
.setCursor(col, row);
col: ตาแหน่งของคอลัมน์ที่เคอร์ เซอร์ ตอ้ งไปรอ (คอลัมน์แรกคือ 0)
row: ตาแหน่งของบรรทัดที่เคอร์ เซอร์ ตอ้ งไปรอ (บรรทัดแรกคือ 0)
ตัวอย่าง lcd.setCursor (6, 1);
หมายถึง ให้เคอร์ เซอร์ ไปรอที่ตาแหน่งคอลัมน์ 6 บรรทัด 1

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
VCC
27 SDA
A4(SDA)
28 SCL
A5(SCL)
R2,R3 GND
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
VCC VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
GND
I
I
VCC
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
SDA
G
G
SCL
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมแสดงข้อความ “Hello, world!” ในบรรทัดบนและ “LCD i2c Lab” บรรทัดล่าง
START
แสดงผล

1 #include <Wire.h>
2 #include <LiquidCrystal_I2C.h>
3 LiquidCrystal_I2C lcd(0x3F,16,2); //0x27 for PCF8574 and 0x3F for PCF8574A
4 void setup()
5 {
6 lcd.init();
7 lcd.backlight();
9 lcd.print("Hello, world!");
11 lcd.print("LCD i2c Lab");
12 }
13 void loop()
14 {
15 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ Wire.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 รวมไฟล์ไลบรารี่ LiquidCrystal_I2C.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 3 กาหนดแอดเดรสของโมดูล I2C และขนาดของ LCD ที่ใช้งาน
- บรรทัดที่ 6 ประกาศเริ่ มใช้งานไลบรารี่
- บรรทัดที่ 7 สัง่ เปิ ดไฟแบล็คไลต์
- บรรทัดที่ 8 ขยับเคอร์ เซอร์ ไปยังตาแหน่งที่ระบุ (Colum ที่ 2, Row ที่ 0)
- บรรทัดที่ 9 แสดงข้อความบนหน้าจอ LCD "Hello, world!"
การทดลองที่ 2 เขียนโปรแกรมแสดงเวลาที่บอร์ ดเริ่ มทางาน โดยแสดงเวลาหน่วยเป็ นวินาทีแสดงผลด้วย

จอ LCD
START
อ่ านค่าเวลาจากบอร์ ด
แสดงผล

1 #include <Wire.h>
4 void setup()
5 {
6 lcd.init();
7 lcd.backlight();
9 lcd.print("Running time");
11 lcd.print("sec");
12 }
13 void loop()
14 {
16 lcd.print(millis()/1000);
17 delay(1000);
18 }
- บรรทัดที่ 2 รวมไฟล์ไลบรารี่ LiquidCrystal_I2C.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 3 กาหนดแอดเดรสของโมดูล I2C และขนาดของ LCD ที่ใช้งาน
- บรรทัดที่ 7 สัง่ เปิ ดไฟแบล็คไลต์
- บรรทัดที่ 9 แสดงข้อความบนหน้าจอ LCD "Hello, world!"
- บรรทัดที่ 16 แสดงข้อมูลที่เกิดจากการคานวนค่าเวลาบนหน้าจอ LCD
4. เปลี่ยนเทียบความแตกต่างของการเขียนโค้ดระหว่างใช้ LCD ธรรมดากับแบบ I2C

1. เขียนโปรแกรมรับค่าจากคียแ์ พด โดยมีเงื่อนไขคือเมื่อมีการกดคียต์ วั เลขจะมีตวั เลขปรากฏที่
LCD คล้า ยการกดเครื่ องคิ ดเลขกล่ า วคื อเมื่ อมี ก ารกดตัวเลขครั้ งที่ ส องเป็ นต้นไปตัวเลข
หลังสุ ดจะดันตัวเลขหน้าสุ ดไปทางซ้ายเรื่ อย ๆ และเมื่อกดคีย ์ * จะล้างข้อมูลหน้าจอทั้งหมด
วงจรที่ใช้ทดลองเป็ นดังรู ป
VCC ARDUINO VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
D12
D11 1 2 3
D10
4 5 6
D9
D8 7 8 9
D7
* 0 #
D6
GND

ใบงานที่ 4.19 การเขียนโปรแกรมแสดงผลด้วยโมดูลตัวเลข MAX7219  231
การเขียนโปรแกรมแสดงผลด้ วยโมดูลตัวเลข MAX7219
เพื่อให้สามารถเขียนโปรแกรมแสดงผลด้วยโมดูลตัวเลข MAX7219 ได้
1. บอกวิธีเขียนโปรแกรมแสดงผลด้วยโมดูลตัวเลข MAX7219 ได้
3. โมดูลตัวเลข MAX7219 1 ตัว
MAX7219 เป็ นไอซี ที่ถูกออกแบบมาสาหรับการแสดงตัวเลขด้วย 7-Segment ได้มากกว่าหนึ่ ง
หลักและยังสามารถนาไปประยุกต์ใช้กบั LED (Dot) matrix ได้อีกด้วย ใบงานนี้เป็ นการใช้งานเฉพาะการ
แสดงผลที่ เป็ นตัวเลขเท่านั้นซึ่ งปั จจุ บ นั มี ผูผ้ ลิ ตเป็ นโมดู ลสาเร็ จรู ป จาหน่ ายมี จานวนตัวเลขในโมดู ล
จานวนทั้งสิ้ น 8 ตัวต่อหนึ่งโมดูล ข้อดีของการแสดงผลที่เป็ นตัวเลขด้วยโมดลู MAX7219 คือสามารถต่อ
พ่วงโมดูลได้อีกหลายโมดูลจึงทาให้สามารถแสดงตัวเลขได้จานวนมากโดยใช้สายสัญญาณจานวนน้อย
เพียง 3 เส้นคือ DIN, CS และ CLK
รู ปที่ 4.19-1 โมดูลแสดงผลตัวเลข 8 หลักด้วยไอซี MAX7219
รู ปที่ 4.19-2 การต่อพ่วงโมดูลแสดงผลหลายหลัก(1)
การเขี ย นโค้ดโปรแกรมเพื่ อใช้ง านการแสดงผลโมดู ล ตัวเลข 8 หลัก ด้วยไอซี MAX7219 มี

ไลบรารี่ ให้เลือกช่วยงานได้ 2 ตัว ซึ่ งแต่ละตัวก็มีขอ้ ดีขอ้ ด้อยแตกต่างกันไปไลบรารี่ ดงั กล่าวคือ
- LedControl.h
- HCMAX7219.h
LedControl.h
เป็ นไลบรารี่ สาหรับแสดงผลโมดูลที่ใช้ไอซี MAX7219 ไลบรารี่ น้ ี ไม่มีมาพร้ อมโปรแกรม Aduino
IDE ดังนั้นการใช้งานจึงต้องมีการติดตั้งเพิ่มเติ่มเข้าไปในโปรแกรม ซึ่งสามารถสามารถดาวน์โหลดได้ที่
LedControl.h https://github.com/wayoda/LedControl/releases
(1)
http://embedded-lab.com/blog/introducing-a-new-serial-spi-8-digit-seven-segment-led-display-module-using-max7219/
การติดตั้งไลบรารี่ มีข้ นั ตอนการดาเนินการเพื่อนาไลบรารี่ มาใช้งานดังนี้


รู ปที่ 4.19-4 การเพิ่มไลบรารี่ ลงในโปรแกรม Arduino IDE

ข้ อดีของไลบรารี่ LedControl.h
1. เลือกใช้ขาเชื่อมต่อใดก็ได้
2. สามารถสร้างรู ปแบบการติดของเซกเมนต์ได้จากฟังกชัน่ ที่มีให้มา
ข้ อเสี ยของไลบรารี่ LedControl.h
1. ไม่สามารถสั่งแสดงผลที่เป็ นตัวเลขหรื อค่าจากตัวแปรที่มีตวั เลขจานวนหลายหลักได้ (ต้องเขียน
ฟังก์ชนั่ แยกหลักเอาเอง)
2. ไม่สามารถสั่งแสดงข้อความที่เป็ นประโยคได้ (ต้องเขียนฟังก์ชนั่ แยกเอง)
HCMAX7219.h
เป็ นไลบรารี่ สาหรับแสดงผลโมดูลที่ใช้ไอซี MAX7219 ไลบรารี่ น้ ี จะต้องใช้ไลบรารี่ เพิ่มอีก 1 ตัวคือ
SPI.h ซึ่ งมีมาพร้ อมโปรแกรม Aduino IDE ไม่ตอ้ งติ ดตั้งเพิ่ม เติ ม แต่จะติ ดตั้งเพิ่ม เติ ม เฉพาะไลบรารี่
HCMAX7219.h ซึ่งสามารถดาวน์โหลดได้ที่
HCMAX7219.h https://github.com/HobbyComponents/HCMAX7219
การติดตั้งไลบรารี่ มีข้ นั ตอนการดาเนิ นการเพื่อนาไลบรารี่ มาใช้งานดังนี้


รู ปที่ 4.19-6 การเพิม่ ไลบรารี่ ลงในโปรแกรม Arduino IDE

ข้ อดีของไลบรารี่ HCMAX7219.h
1. มีฟังก์ชนั่ พิมพ์ขอ้ ความให้ใช้งาน
2. มีฟังก์ชนั่ แสดงตัวเลข (หลายหลักได้) ทั้งเลขจานวนบวก/ลบ และแสดงทศนิยมได้
ข้ อเสี ยของไลบรารี่ HCMAX7219.h
1. เนื่องจากใช้การสื่ อสารด้วย SPI ดังนั้นขาเชื่อมต่อที่เป็ น MOSI,SCLK จึงเปลี่ยนเป็ นขาอื่นไม่ได้
2. การสร้างรู ปแบบการแสดงของแต่ละเซกเมนต์ตอ้ งเข้าไปแก้ในไลบรารี่

delay(ms);
Flow) เมื่อเวลาผ่านไปประมาณ 50 วันหลังจากบอร์ ดเริ่ มทางาน รู ปฟังก์ชนั่ เป็ นดังนี้
millis();
ฟังก์ชั่นใช้ งานของไลบรารี่ LedControl.h

1. ฟังก์ ชั่นกาหนดขาเชื่ อมต่ อ ใช้ในการระบุขาที่ใช้เชื่ อมต่อให้ตวั โปรแกรมรับรู ้วา่ ขาสัญญาณ
ชนิดใดเชื่อมต่ออยูท่ ี่ขาใด รู ปแบบเป็ นดังนี้
LedControl lc=LedControl(dataPin,clkPin,csPin,numDevices);
dataPin: ขาพอร์ตที่ใช้เชื่อมต่อกับขา DIN ของโมดูล
clkPin: ขาพอร์ตที่ใช้เชื่อมต่อกับขา CLK ของโมดูล
csPin: ขาพอร์ตที่ใช้เชื่อมต่อกับขา CS ของโมดูล
numDevices: จานวนโมดูลที่ใช้เชื่อมต่อ
ตัวอย่าง LedControl lc=LedControl(11,13,12,1);
หมายถึง ต่ อไปในโปรแกรมจะใช้ชื่ อ lc ในการเรี ย กใช้งานโมดู ล โดยมี ก ารเชื่ อ มต่ อ
สายสัญญาณ ดังในวงเล็บโดยตัวเลขแรกเป็ นขา DIN ไล่ไปจนตัวเลขสุ ดท้ายเป็ นการบอกว่ามี
การเชื่อมต่อใช้งานโมดูลจานวน 1 ตัว
2. ฟังก์ชั่นสั่ งให้ ทางานหรื อไม่ ทางาน ใช้กาหนดการทางานของโมดูล รู ปแบบเป็ นดังนี้

.shutdown(addr,false);
addr: ตัวเลขแอดเดรสของโมดูล หากเป็ นตัวแรกจะเป็ น 0
false: เริ่ มทางาน
ตัวอย่าง lc.shutdown(0,false);
หมายถึง ให้โมดูลตัวแรก (แอดเดส 0) เริ่ มทางาน
3. ฟังก์ ชั่นกาหนดความสว่าง ใช้กาหนดความสว่างของ LED 7 Segment บนตัวโมดูล รู ปแบบ
.setIntensity(addr,value);
value: ตัวเลขของลาดับความสว่างมีค่าตั้งแต่ 0-15 (ดับสุ ดจนถึงสว่างสุ ด)
4. ฟังก์ชั่นล้ างข้ อมูล ใช้ลา้ งข้อมูลหน้าจอหรื อการทาให้หน้าจอไม่มีอะไรแสดงผลรู ปแบบเป็ น

ดังนี้
.clearDisplay(addr);
5. ฟั งก์ ชั่นแสดงตัวเลข ใช้แสดงตัวเลขแสดงจุดทศนิ ยมในตาแหน่ งที่ระบุบนโมดู ล รู ปแบบ

.setDigit(addr, digit, value, point_decimal);
digit: ต าแหน่ ง ที่ ต้อ งการให้ แ สดงโดยต าแหน่ ง หน้ า สุ ด เป็ นต าแหน่ ง ที่ 7
หลังสุ ดเป็ นตาแหน่ง 0
value: ค่าตัวเลขที่ตอ้ งการแสดงผลมีค่าเท่ากับ 0-9
point_decimal: การแสดงทศนิยม ต้องการแสดงใช้ true ไม่ตอ้ งการใช้ false
6. ฟั งก์ ชั่ นแสดงตั ว อัก ษร ใช้แสดงตัวอัก ษรแสดงจุ ดทศนิ ย มในต าแหน่ ง ที่ ระบุ บ นโมดู ล
ตัวอักษรที่แสดงได้มีเพียงบางตัวได้แก่ A b c d E F H L P . -_ รู ปแบบเป็ นดังนี้
.setChar(addr, digit, character, point_decimal);
หลังสุ ดเป็ นตาแน่ง 0
character: ค่าตัวอักษรที่ต้องการแสดง เวลาใช้ตอ้ งใช้เครื่ องหมาย ‘-‘ ครอบ
ตัวอักษรที่ตอ้ งการให้แสดงผลด้วย
point_decimal: การแสดงทศนิยม ต้องการแสดงใช้ true ไม่ตอ้ งการใช้ false
7. ฟังก์ ชั่นแสดงผลที่กาหนดรู ปแบบเอง ใช้เมื่อต้องการแสดงสิ่ งที่ตอ้ งการโดยการกาหนดการ
ติดดับในแต่ละเซ็กเมนต์ รู ปแบบเป็ นดังนี้
lc.setRow(addr, digit,value);
หลังสุ ดเป็ นตาแน่ง 0
value: ค่าที่ตอ้ งการให้ติดดับ
lc.setDigit(0,7,1,false);
lc.setDigit(0,6,2,true);
lc.setDigit(0,5,3,false);
7 6 5 4 3 2 1 0
VCC
GND
DIN
CS
CLK
lc.setRow(0,2,B00110111); a
f b
Ex Want to display H g
segment dp a b c d e f g e c
data 0 0 1 1 0 1 1 1 d dp
รู ปที่ 4.19-7 การใช้ฟังก์ชนั่ การแสดงผลด้วยไลบรารี่ LedControl.h
ฟังก์ชั่นใช้ งานของไลบรารี่ HCMAX7219.h

1. ฟังก์ ชั่นกาหนดขาเชื่ อมต่ อ ใช้ในการระบุขาที่ใช้เชื่ อมต่อให้ตวั โปรแกรมรับรู ้วา่ ขาสัญญาณ
ชนิ ดใดเชื่ อมต่ออยูท่ ี่ขาใด เนื่ องจากไลบรารี่ น้ ี ใช้การสื่ อสารผ่าน SPI ดังนั้นขาที่ใช้เชื่ อมต่อ
แบบ SPI มี ขาที่ ระบุ แน่ นอนไม่ส ามารถเปลี่ ยนเป็ นขาอื่ นได้ซ่ ึ งขาที่ ใช้งานได้แก่ MOSI,
MISO, CLK, SS รู ปแบบเป็ นดังนี้
HCMAX7219 HCMAX7219(LOAD);
LOAD: ขาพอร์ตที่ใช้เชื่อมต่อกับขา CS ของโมดูลซึ่ งสามารถกาหนดเองได้
2. ฟังก์ชั่นล้ างข้ อมูล ใช้ลา้ งข้อมูลหน้าจอหรื อการทาให้หน้าจอไม่มีอะไรแสดงผลรู ปแบบเป็ น

ดังนี้
.Clear();
3. ฟังก์ ชั่นกาหนดความสว่าง ใช้กาหนดความสว่างของ LED 7 Segment บนตัวโมดูล รู ปแบบ

.Intensity(Level, Driver)
Level: ตัวเลขของลาดับความสว่างมีค่าตั้งแต่ 0-15 (ดับสุ ดจนถึงสว่างสุ ด)
Driver: ตัวเลขแอดเดรสของโมดูล หากเป็ นโมดูลตัวแรกจะเป็ น 0
4. ฟังก์ ชั่นการแสดงผล ไลบรารี่ น้ ี มีฟังก์ชนั่ ส่ งข้อมูลเข้าบัฟเฟอร์ เพื่อแสดงผลใช้เพียงฟั งก์ชนั่

เดียวแต่สามารถแสดงผลได้ 3 รู ปแบบคือ
a. แสดงเป็ นข้ อความ
.print7Seg("TEXT STRING", Offset);
"TEXT STRING": ข้อความที่ตอ้ งการให้แสดงผลซึ่งสามารถป้อนเป็ นคาได้
Offset: ตาแหน่งที่ตอ้ งการให้แสดงของตัวอักษรแรก ตาแหน่งหน้าสุ ดของโมดูลคือ
8 และหลังสุ ดคือ 1
b. แสดงเป็ นตัวเลข
.print7Seg(Value, Offset);
Value: ค่าตัวเลขที่ตอ้ งการให้แสดง (แสดงผลเป็ นเลขฐาน 10)
c. แสดงเป็ นตัวเลขพร้ อมตาแหน่ งทศนิยม
.print7Seg(Value, Decimal_Position, Offset);
Value: ค่าตัวเลขที่ตอ้ งการให้แสดง (แสดงผลเป็ นเลขฐาน 10)
Decimal_Position: ค่าตาแหน่งทศนิยมของตัวเลขนั้น ๆ
5. ฟั งก์ ชั่นแสดงผล ใช้ฟังก์ชนั่ ส่ งค่าจากบัฟเฟอร์ ที่ได้จากฟั งก์ชนั่ HCMAX7219.print7Seg()

เพื่อแสดงผลรู ปแบบเป็ นดังนี้
.Refresh();
HCMAX7219.print7Seg("ABCD",8);
8 7 6 5 4 3 2 1
VCC
GND
DIN
CS
CLK
HCMAX7219.print7Seg(123,2,3);
รู ปที่ 4.19-8 การใช้ฟังก์ชนั่ การแสดงผลด้วยไลบรารี่ HCMAX7219.h
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC VCC
RST MAX7219 7-Segment 4-Digit
C1 VCC
0.1uF 17
D11(MOSI) Din
16
D10(SS) Load
19
D13(SCK) Clk
GND
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
5V
VCC
MAX7219 7-Segment 4-Digit
VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
VCC
GND
F
F
DIN
CS
GND
RST
REF
VIN
3V3
D13
CLK
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1
การทดลองที่ 1 เขียนโปรแกรมแสดงผลบนโมดู ล MAX7219 โดยให้แสดงทั้ง ข้อความทั้ง ตัวเลขที่ มี
ทศนิยมโดยใช้ไลบรารี่ LedControl.h
START
แสดงผล

1 #include "LedControl.h"
2 LedControl lc=LedControl(11,13,10,1); // 11->DIN,13->CLK,10->CS,1->No.devices
3 void setup()
4 {
5 lc.shutdown(0,false); // Enable display
6 lc.setIntensity(0,10); // Set brightness level (0 is min, 15 is max)
7 lc.clearDisplay(0); // Clear display register
8 }
9 void loop()
10 {
11 lc.setDigit(0,7,2,false);
12 lc.setDigit(0,6,3,true);
13 lc.setDigit(0,5,4,false);
14 lc.setRow(0,4,B00110111);
15 lc.setRow(0,3,B01001111);
16 lc.setRow(0,2,B00001110);
17 lc.setRow(0,1,B00001110);
18 lc.setRow(0,0,B01111110);
19 while(1);
20 }
- บรรทัดที่ 1 รวมไฟล์ไลบรารี่ LedControl.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 2 กาหนดขาพอร์ ต Arduino ที่ใช้เชื่อมต่อกับโมดูล MAX7219
- บรรทัดที่ 5 สั่งให้โมดูล MAX7219 เริ่ มทางาน
- บรรทัดที่ 6 กาหนดความสว่างของตัวเลขบนโมดูล MAX7219
- บรรทัดที่ 7 ล้างข้อมูลที่แสดงผลบนโมดูล MAX7219
- บรรทัดที่ 11 แสดงเลข 2 ที่ตาแหน่ง 7 และไม่แสดงทศนิยม
- บรรทัดที่ 12 แสดงเลข 3 ที่ตาแหน่ง 6 และแสดงทศนิยม
- บรรทัดที่ 13 แสดงเลข 4 ที่ตาแหน่ง 5 และไม่แสดงทศนิยม
- บรรทัดที่ 14 ตาแหน่ง 4 ให้ติดสว่างเป็ นตัว “H”
- บรรทัดที่ 15 ตาแหน่ง 3 ให้ติดสว่างเป็ นตัว “E”
- บรรทัดที่ 16 ตาแหน่ง 2 ให้ติดสว่างเป็ นตัว “L”
- บรรทัดที่ 17 ตาแหน่ง 1 ให้ติดสว่างเป็ นตัว “L”
- บรรทัดที่ 18 ตาแหน่ง 0 ให้ติดสว่างเป็ นตัว “O”
- บรรทัดที่ 19 สั่งให้ซีพียวู นอยูก่ บั ที่
การทดลองที่ 2 เขียนโปรแกรมแสดงผลบนโมดู ล MAX7219 โดยให้แสดงทั้งข้อความทั้ง ตัวเลขที่ มี

ทศนิยมโดยใช้ไลบรารี่ HCMAX7219.h
START
แสดงผล

1 /* PINOUT:
2 MODULE.............Arduino
3 VCC................+5V
4 GND................GND
5 DIN................D11(MOSI)
6 CLK................D13(CLK)
7 CS.................D10(SS)
8 */
9 #include <HCMAX7219.h>
10 #include <SPI.h>
11 #define CS 10 //Set the CS pin
12 HCMAX7219 HCMAX7219(CS);
13 void setup()
14 {
15 HCMAX7219.Intensity(10, 0); //Sets the intensity of the LED 0 to 15
16 }
17 void loop()
18 {
19 HCMAX7219.Clear(); // Clear the output buffer
20 HCMAX7219.print7Seg("ABCDE",8);// Write some text to the output buffer
21 HCMAX7219.print7Seg(123,2,3); // Write value to the output buffer
22 HCMAX7219.Refresh(); // Send the output buffer to the display
23 while(1);
24 }
- บรรทัดที่ 1-8 เป็ นส่ วนอธิ บายว่าขาใดของโมดูล MAX7219 เชื่อมต่อกับขาใดของ Arduino
- บรรทัดที่ 9 รวมไฟล์ไลบรารี่ HCMAX7219.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 10 รวมไฟล์ไลบรารี่ SPI.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 11 กาหนดจานวนขาพอร์ ตของ Arduino ที่ใช้เชื่อมต่อขา CS ของโมดูล
- บรรทัดที่ 19 ล้างข้อมูลในบัฟเฟอร์ที่แสดงผลบนโมดูล MAX7219
- บรรทัดที่ 20 ใส่ ขอ้ ความ"ABCD" ลงบัฟเฟอร์ โดยให้เริ่ มแสดงผลตาแหน่งที่ 8
- บรรทัดที่ 21 ใส่ ตวั เลข 123 ที่เป็ นตัวเลขที่มีทศนิยม 2 ตาแหน่งลงบัฟเฟอร์ เริ่ มตาแหน่งที่ 3
- บรรทัดที่ 22 แสดงผลบนโมดูล MAX7219 จากข้อมูลที่อยูใ่ นบัฟเฟอร์
การทดลองที่ 3 เขียนโปรแกรมแสดงค่าของตัวแปรที่กาหนดขึ้นบนโมดูล MAX7219 โดยให้ตวั แปรเริ่ ม

จาก 0-999 โดยใช้ไลบรารี่ HCMAX7219.h
START
แสดงค่ าตัวแปรบนโมดูล
จริ ง เท็จ
ตัวแปร<1000?
เพิ่ม ค่าตัวแปร ล้ างค่าตัวแปร

1 /*
2 PINOUT:
3 MODULE.............Arduino
4 VCC................+5V
5 GND................GND
6 DIN................D11(MOSI)
7 NC(no connection)..D12(MISO)
8 CLK................D13(CLK)
9 CS.................D10(SS)
10 */
12 #include <SPI.h>
13 #define CS 10 // Set the CS pin
14 int value=0;
15 HCMAX7219 HCMAX7219(CS);
16 void setup()
17 {
18 HCMAX7219.Intensity(10, 0); //Sets the intensity of the LED 0 to 15
19 HCMAX7219.Clear(); // Clear the output buffer
20 }
21 void loop()
22 {
23 HCMAX7219.print7Seg(value,8);
24 HCMAX7219.Refresh();
25 delay(250);
26 if(value<1000)
27 value++;
28 else
29 value=0;
30 }
- บรรทัดที่ 9 รวมไฟล์ไลบรารี่ HCMAX7219.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 10 รวมไฟล์ไลบรารี่ SPI.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 11 กาหนดจานวนขาพอร์ ตของ Arduino ที่ใช้เชื่อมต่อขา CS ของโมดูล
- บรรทัดที่ 14 ประกาศใช้งานตัวแปรที่จะนาไปแสดงผล
- บรรทัดที่ 19 ล้างข้อมูลในบัฟเฟอร์ที่แสดงผลบนโมดูล MAX7219
- บรรทัดที่ 23 ใส่ ค่าข้อมูลจากตัวแปรลงบัฟเฟอร์ โดยให้เริ่ มแสดงผลตาแหน่งที่ 8
- บรรทัดที่ 24 แสดงผลบนโมดูล MAX7219 จากข้อมูลที่อยูใ่ นบัฟเฟอร์
- บรรทัดที่ 26-29 ตรวจสอบค่าตัวแปรให้มีค่าอยูใ่ นระหว่าง 0-999

1. เขียนโปรแกรมแสดงเวลาที่บอร์ ดเริ่ มทางานโดยแสดงผลในหน่ วยวินาที วงจรที่ใช้ทดลอง
เป็ นดังรู ป
VCC ARDUINO
5V
VCC
VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
GND

ใบงานที่ 4.20 การเขียนโปรแกรมแสดงผลด้วยจอ OLED 128×64  245
การเขียนโปรแกรมแสดงผลด้ วยจอ OLED ทีเ่ ชื่ อมต่ อแบบ I2C
เพื่อให้สามารถเขียนโปรแกรมแสดงผลด้วยจอ OLED ที่เชื่อมต่อแบบ I2C ได้
1. บอกวิธีเขียนโปรแกรมแสดงผลด้วยจอ OLED ที่เชื่อมต่อแบบ I2C ได้
3. OLED ขนาด 128×64 แบบ I2C ที่ใช้ไดร์เวอร์เบอร์ SSD1306 1 ตัว
OLED (Organic Light-Emitting Diode) เป็ นจอแสดงผลกราฟิ กประเภทหนึ่ งที่ สร้ างจากวัสดุ
"สารกึ่ ง ตัวนาอิ นทรี ย ์" (Organic Semiconductor) ที่ ส ามารถเปล่ งแสงเองได้เมื่ อได้รับ พลัง งานไฟฟ้ า
เรี ยกว่ากระบวนการอิเล็คโทรลูมิเนเซนส์ (Electroluminescence) โดยที่ไม่ตอ้ งพึ่งพาแสงสว่างที่ส่องมา
จากด้านหลัง (Backlight) และจะไม่มีการเปล่งแสงแสดงในบริ เวณที่เป็ นภาพสี ดาส่ งผลให้สีดานั้นดา
สนิทและยังช่วยประหยัดพลังงาน โมดูลแสดงผล OLED ขนาด 128×64 มีหลายแบบให้ผใู ้ ช้งานสามารถ
เลือกใช้ตามความเหมาะสมของแต่ละงานได้ดงั รู ปที่ 4.20-1
รู ปที่ 4.20-1 โมดูลจอ OLED ที่นิยมนามาใช้งานกับไมโครคอนโทรลเลอร์
โมดูลจอแสดงผลกราฟิ กแบบ OLED 128×64 ทั้งที่ใช้การเชื่ อมต่อแบบ I2C และแบบ SPI มีชิพ
ไดร์ เวอร์ อยูด่ ว้ ยกัน 2 เบอร์ ที่มีการใช้งานอย่างแพร่ หลายคือ SSD1306 และ SH1106 ดังนั้นการเตรี ยมการ
จัดหาอุปกรณ์เพื่อนามาใช้งานต้องรู ้วา่ โมดูลจอ OLED ใช้ชิพไดร์ เวอร์ ตวั ใดเนื่ องจากจะต้องใช้ไลบรารี่
ให้ตรงกับชิพไดร์ เวอร์ ของโมดูลจอ
ใบงานนี้เป็ นการทดลองใช้งานโมดูลจอแสดงผลกราฟิ กแบบ OLED ขนาด 128×64 พิกเซลเป็ น
จอแสดงผลแบบให้แสงเพียงสี เดียว (Monochrome) ที่ใช้การเชื่ อมต่อสื่ อสารแบบ I2C และใช้ชิพควบคุม
เบอร์ SSD1306 การเขียนโค้ดโปรแกรมเพื่อใช้งานการแสดงผลจอ OLED จาเป็ นต้องใช้ไลบรารี่ ช่วยงาน
พร้ อม ๆ กันสองตัว ซึ่ งทั้งหมดต้องดาวน์โหลดเพิ่มเติ มเนื่ องจากโปรแกรม Arduino IDE ไม่ได้มีการ
ติดตั้งมาให้ต้ งั แต่เริ่ มต้นจึงจาเป็ นต้องมีการติดตั้งเพิ่มเติ่มเข้าไปในโปรแกรม ไลบรารี่ ท้ งั สองตัวคือ
Adafruit_GFX.h https://github.com/adafruit/Adafruit-GFX-Library
Adafruit_SSD1306.h https://github.com/adafruit/Adafruit_SSD1306
สาหรับ OLED ที่ใช้ชิพควบคุม SH1106.h จะต้องเปลี่ยนไลบรารี่ มาใช้ Adafruit_SH1106.h แทน

Adafruit_SH1106.h https://github.com/wonho-maker/Adafruit_SH1106
การติดตั้งไลบรารี่ มีข้ นั ตอนการดาเนิ นการเพื่อนาไลบรารี่ มาใช้งานดังนี้

1. ดาวน์โหลดไลบรารี่ Adafruit_GFX.h ซึ่งเป็ นไฟล์ Zip ดังรู ป
2. ดาวน์โหลดไลบรารี่ Adafruit_SSD1306.h ซึ่งเป็ นไฟล์ Zip ดังรู ป
3. ทาการเพิ่มไลบรารี่ ท้ งั สองตัวลงในโปรแกรม Arduino IDE โดยการเพิ่มจากไฟล์ zip แล้วทาการ

หาไฟล์ zip ที่ได้จากการดาวน์โหลดในข้อ 1 และ 2
รู ปที่ 4.20-4 การเพิม่ ไลบรารี่ ลงในโปรแกรม Arduino IDE
เนื่ องจากค่าเริ่ มต้นของไลบรารี่ กาหนดขนาด OLED เป็ น 128×32 ดังนั้นเมื่อใช้งานกับ OLED

ขนาด 128×64 จะทาให้ตวั อักษรยืดในแนวตั้ง ซึ่ งจะต้องแก้ไขไฟล์ไลบารี่ Adafruit_SSD1306.h โดยเข้า
ไปยังโฟลเดอร์ ที่เก็บไลบรารี่ แล้วทาการแก้ไขค่าในไฟล์ดงั กล่าว ซึ่ งมีข้ นั ตอนดังนี้
1. เข้าโฟลเดอร์ Documents ของเครื่ องแล้วเข้าโฟลเดอร์ Arduino (คลิก 1, 2, 3)
รู ปที่ 4.20-5 วิธีเข้าโฟลเดอร์ Arduino
2. เข้าไปในโฟลเดอร์ libraries ซึ่ งอยูภ่ ายในโฟลเดอร์ Arduino
รู ปที่ 4.20-6 วิธีเข้าโฟลเดอร์ libraries
3. เข้าไปในโฟลเดอร์ Adafruit_SSD1306 ซึ่ งอยูภ่ ายในโฟลเดอร์ libraries
รู ปที่ 4.20-7 วิธีเข้าโฟลเดอร์ Adafruit_SSD1306
4. เข้าไปแก้ไขไฟล์ Adafruit_SSD1306.h โดยใช้โปรแกรมที่ใช้เปิ ดไฟล์เอกสารได้เช่น WordPad
รู ปที่ 4.20-8 ไฟล์ Adafruit_SSD1306.h

5. ค้นหาค่าเดิมที่ต้ งั ค่าไว้ดงั รู ป
รู ปที่ 4.20-9 ค่าเดิมของไลบรารี่ Adafruit_SSD1306.h
6. ทาการแก้ไขให้เป็ นการกาหนดค่าใช้งาน OLED ขนาด 128x64
รู ปที่ 4.20-10 การแก้ค่าใหม่
ฟังก์ชั่นทีม่ ใี ห้ ใช้ งานของไลบรารี่

ฟังก์ชนั่ ใช้งาน OLED จากไลบรารี่ ที่ติดตั้งมีให้ใช้งานมากพอสมควรดังตารางที่ 4.20-1
ตารางที่ 4.20-1 รายการฟังก์ชนั่ ที่มีให้ใช้งาน
ฟังก์ชนั่ ใช้งาน OLED ฟังก์ชนั่ ใช้งาน OLED
.begin(SSD1306_SWITCHCAPVCC,addr); .fillRect(x0,y0,w,h,color);
.clearDisplay(); .fillRoundRect(x0,y0,w,h,radius,color);
.dim(dim) .fillScreen(color);
.display(); .fillTriangle(x0,y0,x1,y1,x2,y2,color);
.drawBitmap( x,y,*bitmap,w,h,color) .invertDisplay(i)
.drawChar(x,y,c,color,background,size); .print();
.drawCircle(x0,y0,radius,color); .println();
.drawFastHLine(x0,y0,length,color); .setCursor(x0,y0);
.drawFastHLineInternal(x0,y0,w,color) .setRotation(rotation);
.drawFastVLine(x0,y0,length,color); .setTextColor(color);
.drawFastVLineInternal(x,y,h,color) .setTextColor(color,background)
.drawLine(x0,y0,x1,y1,color); .setTextSize(sizes);
.drawPixel(x, y,color); .startscrolldiagleft(start,stop)
.drawRect(x0,y0, w,h,color); .startscrolldiagright(start,stop)
.drawRoundRect(x0,y0,w,h,radius,color); .startscrollleft(start,stop)
.drawTriangle(x0,y0,x1,y1,x2,y2,color); .startscrollright(start,stop)
.fillCircle(x0,y0,radius,color); .stopscroll()
// Dim the display, dim = true: display is dimmed, dim = false: display is normal
//i=1,0
//The rotation screen parameter can be 0, 1, 2 or 3.
// printable sizes from 1 to 8; typical use is 1, 2 or 3
การกาหนดพิกดั ตาแหน่งของฟังก์ชนั่ เขียนภาพในแต่ละฟั งก์ชนั่ จะมีการกาหนดค่าพิกดั ต่าง ๆ

ในแต่ละฟังก์ชนั่ ตัวอย่างเช่น
1. ฟังก์ชนั่ พล๊อตจุด .drawPixel(x, y,color);
รู ปที่ 4.20-11 การกาหนดพิกดั ของฟังก์ชนั่ พล๊อตจุด
2. ฟังก์ชนั่ ลากเส้น เช่น .drawLine(x0,y0,x1,y1,color);
รู ปที่ 4.20-12 การกาหนดพิกดั ของฟังก์ชนั่ ลากเส้น
3. ฟังก์ชนั่ วาดรู ปสี่ เหลี่ยม เช่น .drawRect(x0,y0, w,h,color);
รู ปที่ 4.20-13 การกาหนดพิกดั ของฟังก์ชนั่ วาดรู ปสี่ เหลี่ยม

4. ฟังก์ชนั่ วาดรู ปวงกลม เช่น .drawCircle(x0,y0,radius,color);
รู ปที่ 4.20-14 การกาหนดพิกดั ของฟังก์ชนั่ วาดรู ปวงกลม
5. ฟังก์ชนั่ วาดรู ปสี่ เหลี่ยมหัวมน เช่น .drawRoundRect(x0,y0,w,h,radius,color);
รู ปที่ 4.20-15 การกาหนดพิกดั ของฟังก์ชนั่ วาดรู ปสี่ เหลี่ยมหัวมน
6. ฟังก์ชนั่ วาดรู ปสามเหลี่ยม เช่น .drawTriangle(x0,y0,x1,y1,x2,y2,color);
รู ปที่ 4.20-16 การกาหนดพิกดั ของฟังก์ชนั่ วาดรู ปสามเหลี่ยม

ฟอนต์ ทมี่ ใี ห้ ใช้ งานของไลบรารี่

การแสดงผลที่เป็ นข้อความผูใ้ ช้งานสามารถเปลี่ยนฟอนต์ได้ โดยไฟล์ฟอนต์จะอยู่ในไลบรารี่
Adafruit_GFX ภายในโฟลเดอร์ \libraries\Adafruit_GFX_Library\Fonts มีรายการฟอนต์ให้เลื อกใช้ได้
ดังตารางที่ 4.20-2
ตารางที่ 4.20-2 รายการฟอนต์ที่มีให้เลือกใช้งาน
Font Font
FreeMono12pt7b.h FreeSansBoldOblique12pt7b.h
FreeMonoBold12pt7b.h FreeSansOblique12pt7b.h
FreeMonoBoldOblique12pt7b.h FreeSerif12pt7b.h
FreeMonoOblique12pt7b.h FreeSerifBold12pt7b.h
FreeSans12pt7b.h FreeSerifBoldItalic12pt7b.h
FreeSansBold12pt7b.h FreeSerifItalic12pt7b.h
ผูใ้ ช้งานสามารถเรี ย กใช้ไ ด้โดยการ include ไฟล์ฟอนต์ดงั กล่ าวเข้าในโปรแกรมแล้วท าการ

เรี ยกใช้ เพียงแต่ตาแหน่งของตัวอักษรที่ใช้กาหนดตาแหน่งจะแตกต่างกันกับที่ไม่ได้มีการใช้ฟอนต์ดงั รู ป
รู ปที่ 4.20-17 การกาหนดพิกดั เมื่อใช้ฟอนต์ปกติกบั ฟอนต์ใหม่


delay(ms);
ฟังก์ชั่นใช้ งานของไลบรารี่ (เฉพาะในใบงาน)

การใช้งานแสดงผลด้วยโมดูลจอ OLED ที่ใช้ไลบรารี่ ของ Adafruit มีฟังก์ชนั่ ให้ใช้งานจานวน
มากดังได้กล่าวมาแล้วข้างต้น สาหรับรายละเอียดการใช้งานของแต่ละฟั งก์ชนั่ จะกล่าวเฉพาะที่นามาใช้
งานในการทดลองเพื่อเป็ นแนวทางในการใช้งานฟังก์ชนั่ ๆ ได้แก่
1. ฟั งก์ ชั่นเริ่ มต้ นการใช้ งานและกาหนดแอดเดรส ใช้ในการเริ่ มต้นการใช้งานไลบรารี่ และ

กาหนดแอดเดรสของโมดูลจอ OLED ที่สื่อสารแบบ I2C รู ปแบบเป็ นดังนี้
.begin(SSD1306_SWITCHCAPVCC,addr);
addr: แอดเดรสของโมดูล I2C
ตัวอย่าง OLED.begin(SSD1306_SWITCHCAPVCC,0x3C);
หมายถึง เริ่ มต้นการใช้งานไลบรารี่ โดยโมดูลเชื่อมต่อมีแอดเดรสเป็ น 3CH
2. ฟังก์ชั่นล้ างข้ อมูลหน้ าจอ ใช้ในการล้างข้อมูลที่แสดงผลบนหน้าจอ OLED รู ปแบบเป็ นดังนี้

.clearDisplay();
3. ฟั งก์ ชั่นแสดงผล ใช้ในการแสดงผลบนหน้าจอ OLED จากข้อมูลในบัฟเฟอร์ รู ปแบบเป็ น

ดังนี้
.display();
4. ฟังก์ชั่นวาดเส้ นวงกลม ใช้ในการวาดเส้นวงกลมไม่มีสีพ้นื รู ปแบบเป็ นดังนี้

.drawCircle(x0,y0,radius,color);
x0: พิกดั ที่ตาแหน่งเริ่ มวาดแกน x

y0: พิกดั ที่ตาแหน่งเริ่ มวาดแกน y
radius: รัศมีของวงกลม
color: สี ที่ตอ้ งการแสดง (BLACK, WHITE)
ตัวอย่าง OLED.drawCircle(110, 50, 12, WHITE);
หมายถึง วาดเส้นวงกลมสี ขาวที่พิกดั (110,50) โดยมีรัศมี 12 พิกเซล
5. ฟังก์ชั่นวาดเส้ นตรง ใช้ในการเส้นตรง รู ปแบบเป็ นดังนี้

.drawLine(x0,y0,x1,y1,color);
x1: พิกดั ที่ตาแหน่งท้ายของการวาดเส้นตรงในแกน x
y1: พิกดั ที่ตาแหน่งท้ายของการวาดเส้นตรงในแกน y
ตัวอย่าง OLED.drawLine(0, 63, 127, 0, WHITE);
หมายถึง วาดเส้นตรงสี ขาวเริ่ มที่พิกดั (0,63) ไปสิ้ นสุ ดที่พิกดั (127,0)
6. ฟังก์ชั่นวาดรู ปสี่ เหลีย่ ม วาดรู ปสี่ เหลี่ยมพื้นโปร่ งใส รู ปแบบเป็ นดังนี้

.drawRect(x0,y0, w,h,color);
w: ความกว้างของรู ปสี่ เหลี่ยม
h: ความสู งของรู ปสี่ เหลี่ยม
ตัวอย่าง OLED.drawRect(10,10, 100,40,WHITE);
หมายถึง วาดรู ปสี่ เหลี่ยมสี ขาวเริ่ มที่พิกดั (10,10) ไปสิ้ นสุ ดที่พิกดั (100,40)
7. ฟังก์ชั่นวาดรู ปสามเหลีย่ ม วาดรู ปสามเหลี่ยมพื้นโปร่ งใส รู ปแบบเป็ นดังนี้

.drawTriangle(x0,y0,x1,y1,x2,y2,color);
x1: พิกดั จุดที่สองของการลากเส้นของแกน x

y1: พิกดั ที่จุดที่สองของการลากเส้นของแกน y
x2: พิกดั จุดที่สามของการลากเส้นของแกน x
y2: พิกดั จุดที่สามของการลากเส้นของแกน y
ตัวอย่าง OLED.drawTriangle(70, 60, 90, 60, 80, 46, WHITE);
หมายถึง วาดรู ปสามเหลี่ยมสี ขาวที่พิกดั แกน x, y ดังนี้ (70,60) (90,60) (80,46)
8. ฟังก์ชั่นวาดวงกลมชนิดมีสีพืน้ รู ปแบบเป็ นดังนี้

.fillCircle(x0,y0,radius,color);
radius: รัศมีของวงกลม
ตัวอย่าง OLED.fillCircle(110, 50, 12, WHITE);
หมายถึง วาดวงกลมทึบสี พ้นื เป็ นสี ขาวที่พิกดั (110,50) โดยมีรัศมี 12 พิกเซล
9. ฟังก์ชั่นวาดรู ปสี่ เหลีย่ มชนิดมีสีพืน้ รู ปแบบเป็ นดังนี้

.fillRect(x0,y0,w,h,color);
ตัวอย่าง OLED.fillRect(10,10, 100,40,WHITE);
หมายถึง วาดรู ปสี่ เหลี่ยมพื้นสี ขาวเริ่ มที่พิกดั (10,10) ไปสิ้ นสุ ดที่พิกดั (100,40)
10. ฟังก์ชั่นวาดรู ปสี่ เหลีย่ มหัวมนชนิดมีสีพืน้ รู ปแบบเป็ นดังนี้

.fillRoundRect(x0,y0,w,h,radius,color);

radius: รัศมีของส่ วนโค้งหัวมน
ตัวอย่าง OLED.fillRoundRect (10,10, 100,40,WHITE);
หมายถึง วาดรู ปสี่ เหลี่ยมพื้นสี ขาวเริ่ มที่พิกดั (10,10) ไปสิ้ นสุ ดที่พิกดั (100,40)
11. ฟั งก์ ชั่นพิมพ์ ข้อความ เป็ นฟั งก์ชนั่ ที่ใช้ในพิมพ์ขอ้ ความหรื อค่าในตัวแปรให้แสดงบนจอ
OLED รู ปแบบการใช้งานคล้ายคลึ งกับ Serial.print() นัน่ คือเมื่อพิมพ์เสร็ จตัวเคอร์ เซอร์ จะ
รออยูท่ ี่ทา้ ยสิ่ งที่พิมพ์น้ นั ๆ รู ปแบบเป็ นดังนี้
.print();
12. ฟังก์ ชั่นพิมพ์ ข้อความ ใช้ในพิมพ์ขอ้ ความหรื อค่าในตัวแปรให้แสดงบนจอ OLED รู ปแบบ

การใช้งานคล้ายคลึ งกับ Serial.println() นั่นคื อเมื่อพิมพ์เสร็ จตัวเคอร์ เซอร์ จะขยับ มาขึ้ น
บรรทัดใหม่รอฟังก์ชนั่ พิมพ์ขอ้ ความต่อไป รู ปแบบเป็ นดังนี้
.println();
13. ฟั งก์ ชั่นกาหนดตาแหน่ งเคอร์ เซอร์ สาหรั บพิมพ์ ข้อความ เป็ นฟั งก์ชั่นกาหนดพิกดั ให้กบั
เคอร์ เซอร์ เพื่อใช้พิมพ์ขอ้ ความในตาแหน่งที่ตอ้ งการ รู ปแบบเป็ นดังนี้
.setCursor(x0,y0);
x0: พิกดั แกน x
y0: พิกดั แกน y
14. ฟังก์ ชั่นเรียกใช้ งานฟอนต์ เป็ นฟั งก์ชนั่ ที่ใช้เรี ยกใช้งานฟอนต์ที่ตอ้ งการโดยใส่ ชื่อฟอนต์ที่
ต้องการใช้งาน (ชื่อฟอนต์ในตารางที่ 4.20-2) รู ปแบบเป็ นดังนี้
.setFont(&Font);
Font: ชื่อฟอนต์ที่ตอ้ งการใช้งาน(ไม่ตอ้ งใส่ สกุล .h)
ตัวอย่าง OLED.setFont(&FreeMonoBold9pt7b);
หมายถึง ใช้งานฟอนต์ที่ชื่อว่า FreeMonoBold9pt7b
15. ฟังก์ ชั่นกาหนดสี ข้อความ ใช้ในการกาหนดสี ของตัวข้อความและพื้นหลังข้อความ รู ปแบบ

.setTextColor(color,background)
color: สี ของข้อความที่ตอ้ งการแสดง (BLACK, WHITE)
background: สี ของพื้นหลังข้อความที่ตอ้ งการแสดง (BLACK, WHITE)
16. ฟังก์ ชั่นกาหนดขนาดของตัวอักษร ใช้ในการกาหนดขนาดของตัวอักษรที่ตอ้ งการแสดงผล

บนจอ OLED รู ปแบบเป็ นดังนี้
.setTextSize(sizes);
sizes: ตัวเลขขนาดที่ตอ้ งการสามารถใช้งานได้ต้ งั แต่ 1-8
วงจรเพื่อใช้ทดลองในใบงานสามารถทาได้ 2 แนวทาง คือ
เนื่องจากไม่มีโมเดลจาลอง OLED ในโปรแกรม Proteus จึงไม่สามารถจาลองการทางานได้

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
VCC
27
A4(SDA)
28
A5(SCL)
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V VCC GND SCL SDA
GND
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
VCC VCC
A4(SDA)
A5(SCL)
VCC GND SCL SDA
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมแสดงผลบนจอ OLED ที่มีท้ งั ข้อความและค่าในตัวแปร
START
แสดงผล

1 #include <Wire.h>
2 #include <Adafruit_GFX.h>
3 #include <Adafruit_SSD1306.h>
4 Adafruit_SSD1306 OLED(4);
5 int x;
6 void setup()
7 {
8 OLED.begin(SSD1306_SWITCHCAPVCC,0x3C); // initialize with the I2C addr 0x3C
9 }
10 void loop()
11 {
12 OLED.clearDisplay();
13 OLED.setTextColor(WHITE,BLACK); //Text is white ,background is black

14 OLED.setCursor(0, 0);
15 OLED.setTextSize(2);
16 OLED.println("OLED ");
18 OLED.println("Arduino Laboratory");
19 OLED.setTextColor(BLACK,WHITE); // 'inverted' text
20 OLED.print("www.praphas.com");
21 OLED.setTextColor(WHITE,BLACK); // 'inverted' text again
22 OLED.setCursor(60,0);
24 OLED.println(x,DEC);
25 OLED.display(); //
26 x++;
27 delay(250);
28 }
- บรรทัดที่ 2 รวมไฟล์ไลบรารี่ Adafruit_GFX.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 3 รวมไฟล์ไลบรารี่ Adafruit_SSD1306.h เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 4 กาหนดชื่อเรี ยกโมดูลจอว่า OLED
- บรรทัดที่ 8 ประกาศเริ่ มใช้งานไลบรารี่ พร้อมระบุแอดเดรสจอ OLED
- บรรทัดที่ 12 ล้างข้อมูลที่แสดงผลหน้าจอ
- บรรทัดที่ 13 กาหนดสี ตวั อักษรและสี พ้นื หลังของตัวอักษร
- บรรทัดที่ 14 กาหนดพิกดั ที่จะพิมพ์ขอ้ ความ
- บรรทัดที่ 15 กาหนดขนาดของตัวอักษร
- บรรทัดที่ 16 แสดงผลข้อความแล้วให้เคอร์ เซอร์ ข้ ึนไปรอที่บรรทัดใหม่
- บรรทัดที่ 24 แสดงผลจากค่าของตัวแปรแล้วให้เคอร์ เซอร์ ข้ ึนไปรอที่บรรทัดใหม่
- บรรทัดที่ 25 สั่งให้แสดงผล
การทดลองที่ 2 เขียนโปรแกรมวาดวัตถุแบบต่าง ๆ โดยแสดงผลที่จอ OLED
START
วาดวัตถุแบบต่ าง
แสดงผล

1 #include <Wire.h>
5 void setup()
6 {
7 OLED.begin(SSD1306_SWITCHCAPVCC,0x3C); //initialize I2C addr 0x3c
8 }
9 void loop()
10 {
12 OLED.setTextColor(WHITE,BLACK);
13 OLED.drawRect(10,10, 100,40,WHITE);
14 OLED.drawLine(0, 63, 127, 0, WHITE);
15 OLED.drawCircle(110, 50, 12, WHITE);
16 OLED.fillCircle(45, 50, 8, WHITE);
17 OLED.drawTriangle(70, 60, 90, 60, 80, 46, WHITE);
18 OLED.fillRect(15,15,20,20,WHITE);
19 OLED.fillRoundRect(50,15,50,20,10,WHITE);
22 OLED.println("www.praphas.com");
24 delay(250);
25 }
- บรรทัดที่ 13 วาดรู ปสี่ เหลี่ยมพื้นโปร่ งใส
- บรรทัดที่ 14 วาดเส้นตรง
- บรรทัดที่ 15 วาดรู ปวงกลมพื้นโปร่ งใส
- บรรทัดที่ 16 วาดรู ปวงกลมพื้นทึบสี ขาว
- บรรทัดที่ 17 วาดรู ปสามเหลี่ยมพื้นโปร่ งใส
การทดลองที่ 3 เขียนโปรแกรมแสดงข้อความโดยเปลี่ยนฟอน์ตการแสดงผล
START
เลือ กใช้ ฟอนต์
แสดงผล

1 #include <Wire.h>
4 #include <Fonts/FreeMonoBold9pt7b.h> //include font MonoBold size 9pt7b
6 void setup()
7 {
8 OLED.setFont(&FreeMonoBold9pt7b); // Use font from file include
10 }
11 void loop()
12 {
17 OLED.println("Change font");
19 OLED.print("OLED 128x64");
21 delay(250);
22 }
- บรรทัดที่ 4 รวมไฟล์ฟอนต์เข้ามาในโค้ดโปรแกรม
- บรรทัดที่ 8 ประกาศใช้งานฟอนต์
- บรรทัดที่ 15 กาหนดพิกดั ที่จะพิมพ์ขอ้ ความ
- บรรทัดที่ 16 กาหนดขนาดของตัวอักษร
- บรรทัดที่ 17 แสดงผลข้อความแล้วให้เคอร์ เซอร์ ข้ ึนไปรอที่บรรทัดใหม่

1. เขียนโปรแกรมแสดงผลเวลาที่บอร์ ดเริ่ มทางานโดยให้แสดงผลเวลาหน่วยเป็ นวินาทีพร้ อม
ข้อความบอกรายละเอียดต่าง ๆ พอสมควร วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
VCC VCC
A4(SDA)
A5(SCL)
VCC GND SCL SDA
GND

ใบงานที่ 4.21 การเขียนโปรแกรมแสดงผลรู ปภาพด้วยจอ OLED 128×64  263
การเขียนโปรแกรมแสดงผลรู ปภาพด้ วยจอ OLED 128×64
เพื่อให้สามารถเขียนโปรแกรมแสดงผลรู ปภาพด้วยจอ OLED 128×64 ได้
1. บอกวิธีเขียนโปรแกรมแสดงผลรู ปภาพด้วยจอ OLED 128×64ได้
3. OLED ขนาด 128×64 แบบ I2C ที่ใช้ไดร์เวอร์เบอร์ SSD1306 1 ตัว
รู ปภาพที่แสดงผลบนจอ OLED ขนาด 128×64 สามารถทาได้ 2 วิธีหลัก ๆ คือ เขียนขึ้นมาใหม่
และใช้รูปภาพที่มีอยู่แล้ว สาหรับการเขียนรู ปภาพขึ้นมาใหม่สามารถใช้โปรแกรมวาดรู ปภาพทัว่ ๆ ไป
เขียนรู ปภาพที่ตอ้ งการได้เพียงการเขียนรู ปภาพให้ได้ตามต้องการมีความซับซ้อนมากพอสมควรสาหรับ
ผูท้ ี่ไม่มีทกั ษะในการวาดรู ปด้วยแล้วแทบจะเป็ นไปไม่ได้เลย งานครั้งนี้เสนอการนารู ปภาพที่มีอยูแ่ ล้วซึ่ ง
เป็ นวิธีที่ง่ายสุ ดคือการค้นหารู ปภาพที่ตอ้ งการทางอินเตอร์เน็ตมีข้ นั ตอนการดาเนินการดังนี้
ขั้นตอนการดาเนินการ
1. เปิ ดหาภาพทีต่ ้ องการ เป็ นการหารู ปภาพจากแหล่งต่าง ๆ ที่มีลกั ษณะตามที่ตอ้ งการและมีขนาดที่
สามารถใช้งานได้ ตัวอย่างเช่ นจากเวปไซต์ http://www.alessioatzeni.com/meteocons ซึ่ งเป็ น
ภาพขาวดาและมีขนาดใกล้เคียงกับที่ตอ้ งการ หากภาพเล็กหรื อใหญ่เกินความต้องการสามารถ
ปรับขยาย/ย่อการแสดงผลในโปรแกรมบราวน์เซอร์ (โปรแกรมที่กาลังเปิ ดเวป) เพื่อให้ได้ขนาด
ที่ตอ้ งการและมีขนาดไม่เกินขนาดของหน้าจอ OLED ที่ใช้งาน การปรับขยาย/ย่อทาได้โดยการ
กดแป้นพิมพ์ Ctrl ค้างไว้แล้วกลิ้งเมาส์ให้ได้ขนาดตามต้องการ
รู ปที่ 4.21-1 ตัวอย่างภาพจากเวปไซต์ที่ตอ้ งการจับภาพ
2. จับภาพหน้ าจอด้ วยโปรแกรมจับภาพ เช่นโปรแกรม SnagIt สามารถดาวน์โหลดโปรแกรมได้ที่

https://www.techsmith.com/download/snagit ทาการจับภาพเฉพาะไอคอนที่ตอ้ งการ โดยขนาด
ของภาพทั้งแนวตั้งและแนวนอนจะต้องเป็ นค่าที่เลข 8 สามารถหารได้ลงตัวถึงจะสามารถนาไป
แสดงผลได้ถูกต้อง เช่น 56×56 ดังรู ป
รู ปที่ 4.21-2 จับภาพที่ตอ้ งการโดยขนาดที่ใช้เลข 8 หารลงตัว

รู ปที่ 4.21-3 ภาพที่จบั ได้จากหน้าจอด้วยโปรแกรม Snagit
3. ใช้ โปรแกรมแปลงภาพเป็ นรหัส "LCD Image Converter" สามารถดาวน์โหลดโปรแกรมได้ที่

http://www.riuson.com/lcd-image-converter ท าการเปิ ดให้โ ปรแกรมค้า งไว้ แล้ว กลับ ไปยัง
โปรแกรม Snagit (รู ปที่ 4.21-3) ทาการคัดลอกภาพโดยใช้ Ctrl+c แล้วกลับมายังโปรแกรม LCD
Image Converter อีกครั้งทาการวางภาพที่คดั ลอกมาโดยใช้ Ctrl+v ทาการซูมภาพเพื่อให้สามารถ
ปรั บ สี ใ นแต่ ล ะพิ ก เซลได้ถนัดโดยการกดคี ย ์ Ctrl ค้า งไว้แล้วกลิ้ ง ลู ก กลิ้ งเมาส์ ใ ห้ได้ข นาดที่
สามารถแก้ไขภาพได้อย่างถนัดตามความต้องการ ทาการปรับสี ภาพแต่ละพิกเซลให้ได้ตามที่
ต้องการโดยใช้การคลิกเมาส์ที่เครื่ องมือดินสอ แล้วมาคลิกที่ภาพดังนี้
- คลิกซ้ายจะเติมสี ดา
- คลิกขวาจะเติมสี ขวา
รู ปที่ 4.21-4 ภาพที่นาเข้าโปรแกรม LCD Image Converter
รู ปที่ 4.21-5 ภาพที่ตกแต่งเรี ยบร้อยแล้ว

4. การดูขนาดรู ปภาพ ว่าใช้งานได้หรื อไม่ หากเป็ นขนาดที่เลข 8 หารไม่ลงตัวจะต้องทาการปรับ

เพิ่ม/ลดขนาดให้หารลงตัวให้ได้ การดูขนาดดูได้ที่มุมขวาล่างของโปรแกรมดังรู ป
รู ปที่ 4.21-6 ดูขนาดภาพ
5. ปรับขนาดรู ปภาพให้ แสดงผลได้ ขนาดรู ปภาพที่ใช้งานได้จะต้องมีขนาดพิกเซลไม่เกินจอคือไม่

เกิน 128×64 และต้องเป็ นขนาดที่เลข 8 หารลงตัว หากดูขนาดจากขั้นตอนที่ 4 แล้วเห็นว่าขนาด
ยังไม่ถูกต้องจะต้องปรับขนาดโดยดาเนินการดังรู ป
รู ปที่ 4.21-6 ดูขนาดภาพ
รู ปที่ 4.21-7 ปรับขนาดภาพเพิม่ ลดซ้าย/ขวา/บน/ล่าง
6. กลับสี รูปภาพเป็ นตรงข้ าม ในกรณี ที่รูปภาพที่ได้ตอ้ งการให้ติดสว่างบริ เวณที่เป็ นสี ขาวและให้

มืดบริ เวณที่เป็ นสี ดาจะต้องทาการกลับสี ภาพโดยใช้เมนู Image-> Inverse ดังรู ป
รู ปที่ 4.21-7 กลับสี ภาพ

รู ปที่ 4.21-8 ผลของการกลับสี รูปภาพ

7. เตรี ยมการคั ด ลอกโค้ ด คลิ ก ที่ เมนู Option เลื อก Conversion คลิ ก เลื อก Monochrome(1) และ
Show Preview(2)
รู ปที่ 4.21-9 เตรี ยมการคัดลอกโค้ดรู ปภาพ

8. คัดลอกโค้ ดรู ปภาพ โดยการคลิกขวาที่บริ เวณโค้ดเลือก Select All และ Copy ตามลาดับ
รู ปที่ 4.21-10 เลือกโค้ดภาพทั้งหมด
รู ปที่ 4.21-11 คัดลอกโค้ดภาพ

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

เก็บโปรแกรม const unsigned char logo [] PROGMEM = {
รู ปที่ 4.21-12 วางโค้ดรู ปภาพในตัวแปรอาเรย์

10. แก้ขนาดรู ปภาพทีก่ าหนด ทาการแก้ขนาดรู ปภาพให้ตรงตามขนาดจริ งในฟังก์ชนั่ .drawBitmap
รู ปที่ 4.21-13 แก้ขนาดให้ตรงกับขนาดภาพที่ใช้งาน

delay(ms);
ฟังก์ชั่นใช้ งานของไลบรารี่ (เฉพาะในใบงาน)

ฟังก์ชนั่ ที่ใช้ในการทดลองในใบงาน ได้แก่
1. ฟั งก์ ชั่นเริ่ มต้ นการใช้ งานและกาหนดแอดเดรส ใช้ในการเริ่ มต้นการใช้งานไลบรารี่ และ
กาหนดแอดเดรสของโมดูลจอ OLED ที่สื่อสารแบบ I2C รู ปแบบเป็ นดังนี้
.begin(SSD1306_SWITCHCAPVCC,addr);
addr: แอดเดรสของโมดูล I2C
2. ฟังก์ชั่นวาดรู ปภาพ ใช้ในวาดรู ปภาพที่เก็บไว้ในตัวแปร รู ปแบบเป็ นดังนี้

.drawBitmap( x,y,*bitmap,w,h,color)
x: พิกดั ที่ตาแหน่งเริ่ มวาดแกน x
y: พิกดั ที่ตาแหน่งเริ่ มวาดแกน y
*bitmap: ชื่อตัวแปรที่เก็บรู ปภาพ
w: ขนาดพิกเซลด้านความกว้างของรู ปภาพ
h: ขนาดพิกเซลด้านความสู งของรู ปภาพ
color: สี ที่ใช้วาด (0,1)
ตัวอย่าง OLED.drawBitmap(20,10,logo,56,56,1);
หมายถึง วาดรู ปภาพจากตัวแปร logo ที่พิกดั (20,10) โดยขนาดของรู ปภาพคือ (56,56)
3. ฟังก์ชั่นล้ างข้ อมูลหน้ าจอ ใช้ในการล้างข้อมูลที่แสดงผลบนหน้าจอ OLED รู ปแบบเป็ นดังนี้

.clearDisplay();
4. ฟั งก์ ชั่นแสดงผล ใช้ในการแสดงผลบนหน้าจอ OLED จากข้อมูลในบัฟเฟอร์ รู ปแบบเป็ น

ดังนี้
.display();
5. ฟังก์ ชั่นพิมพ์ ข้อความ เป็ นฟั งก์ชนั่ ที่ใช้ในการพิมพ์ขอ้ ความหรื อค่าในตัวแปรให้แสดงบน

จอ OLED โดยรู ป แบบการใช้ ง านคล้า ยคลึ ง กับ Serial.print() นั่น คื อ เมื่ อ พิ ม พ์เ สร็ จ ตัว
เคอร์ เซอร์ จะรออยูท่ ี่ทา้ ยสิ่ งที่พิมพ์น้ นั ๆ รู ปแบบเป็ นดังนี้
.print();
6. ฟังก์ ชั่นพิมพ์ ข้อความ ใช้ในการพิมพ์ขอ้ ความหรื อค่าในตัวแปรให้แสดงบนจอ OLED โดย

รู ปแบบการใช้งานคล้ายคลึงกับ Serial.println() นัน่ คือเมื่อพิมพ์เสร็ จตัวเคอร์ เซอร์จะขยับมา
ขึ้นบรรทัดใหม่รอฟังก์ชนั่ พิมพ์ขอ้ ความต่อไป รู ปแบบเป็ นดังนี้
.println();
7. ฟั งก์ ชั่นกาหนดตาแหน่ งเคอร์ เซอร์ สาหรั บพิมพ์ ข้อความ เป็ นฟั งก์ชั่นกาหนดพิกดั ให้กบั
เคอร์ เซอร์ เพื่อใช้พิมพ์ขอ้ ความในตาแหน่งที่ตอ้ งการ รู ปแบบเป็ นดังนี้
.setCursor(x0,y0);
x0: พิกดั แกน x
y0: พิกดั แกน y
8. ฟังก์ ชั่นเรียกใช้ งานฟอนต์ เป็ นฟั งก์ชนั่ ที่ใช้เรี ยกใช้งานฟอนต์ที่ตอ้ งการโดยใส่ ชื่อฟอนต์ที่
ต้องการใช้งาน (ชื่อฟอนต์ในตารางที่ 4.20-2) รู ปแบบเป็ นดังนี้
.setFont(&Font);
Font: ชื่อฟอนต์ที่ตอ้ งการใช้งาน (ไม่ตอ้ งใส่ สกุล .h)
9. ฟังก์ ชั่นกาหนดสี ข้อความ ใช้ในการกาหนดสี ของตัวข้อความและพื้นหลังข้อความ รู ปแบบ

.setTextColor(color,background)
color: สี ของข้อความที่ตอ้ งการแสดง (BLACK, WHITE)
background: สี ของพื้นหลังข้อความที่ตอ้ งการแสดง (BLACK, WHITE)
10. ฟังก์ ชั่นกาหนดขนาดของตัวอักษร ใช้ในการกาหนดขนาดของตัวอักษรที่ตอ้ งการแสดงผล

บนจอ OLED รู ปแบบเป็ นดังนี้
.setTextSize(sizes);
sizes: ตัวเลขขนาดที่ตอ้ งการสามารถใช้งานได้ต้ งั แต่ 1-8
วงจรเพื่อใช้ทดลองในใบงานสามารถทาได้ 2 แนวทาง คือ
เนื่องจากไม่มีโมเดลจาลอง OLED ในโปรแกรม Proteus จึงไม่สามารถจาลองการทางานได้

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
VCC
27
A4(SDA)
28
A5(SCL)
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V VCC GND SCL SDA
GND
3V3
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
VCC VCC
A4(SDA)
A5(SCL)
VCC GND SCL SDA
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมแสดงภาพบนจอ OLED
START
แสดงผล

1 #include <Wire.h>
5 const unsigned char logo [] PROGMEM = {
6 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
9 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
10 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00,
11 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00,
12 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00,
13 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00,
14 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
15 0x00, 0x18, 0x00, 0x00, 0x0c, 0x00, 0x00,
16 0x00, 0x1c, 0x00, 0x00, 0x1c, 0x00, 0x00,
17 0x00, 0x0e, 0x00, 0x00, 0x38, 0x00, 0x00,
18 0x00, 0x06, 0x07, 0xf8, 0x30, 0x00, 0x00,
19 0x00, 0x00, 0x1f, 0xfc, 0x00, 0x00, 0x00,
20 0x00, 0x00, 0x3f, 0xfe, 0x00, 0x00, 0x00,
21 0x00, 0x00, 0x78, 0x0f, 0x00, 0x00, 0x00,
22 0x00, 0x00, 0xf0, 0x07, 0x80, 0x00, 0x00,
23 0x00, 0x01, 0xe0, 0x03, 0x80, 0x00, 0x00,
24 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x00, 0x00,
25 0x00, 0x03, 0x80, 0x01, 0xc0, 0x00, 0x00,
26 0x00, 0x03, 0x80, 0x00, 0xe0, 0x00, 0x00,
27 0x03, 0xc3, 0x80, 0xff, 0xe1, 0xe0, 0x00,
28 0x07, 0xe3, 0x81, 0xff, 0xf3, 0xf0, 0x00,
29 0x03, 0xc3, 0x87, 0xff, 0xf9, 0xe0, 0x00,
30 0x00, 0x03, 0x8f, 0x80, 0x7c, 0x00, 0x00,
31 0x00, 0x01, 0xfe, 0x00, 0x1e, 0x00, 0x00,
32 0x00, 0x01, 0xfc, 0x00, 0x0f, 0x00, 0x00,
33 0x00, 0x0f, 0xf8, 0x00, 0x07, 0xfc, 0x00,
34 0x00, 0x3f, 0xf0, 0x00, 0x03, 0xff, 0x00,
35 0x00, 0x7f, 0xc0, 0x00, 0x01, 0xff, 0x80,
36 0x00, 0xfc, 0x00, 0x00, 0x00, 0x07, 0xc0,
37 0x01, 0xf0, 0x00, 0x00, 0x00, 0x01, 0xe0,
38 0x03, 0xe0, 0x00, 0x00, 0x00, 0x00, 0xf0,
39 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x70,
40 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78,
41 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
42 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
43 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
44 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
45 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x78,
46 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x78,
47 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, 0xf0,
48 0x03, 0xc0, 0x00, 0x00, 0x00, 0x01, 0xf0,
49 0x01, 0xe0, 0x30, 0x00, 0x01, 0x83, 0xe0,

50 0x00, 0xfc, 0x78, 0x00, 0x07, 0xc7, 0xc0,
51 0x00, 0x7f, 0xfc, 0x00, 0x1f, 0xff, 0x80,
52 0x00, 0x3f, 0xff, 0x00, 0x3f, 0xff, 0x00,
53 0x00, 0x0f, 0xcf, 0xe0, 0xfe, 0x7c, 0x00,
54 0x00, 0x00, 0x07, 0xff, 0xfc, 0x00, 0x00,
55 0x00, 0x00, 0x03, 0xff, 0xf0, 0x00, 0x00,
56 0x00, 0x00, 0x00, 0xff, 0xc0, 0x00, 0x00,
57 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
58 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
59 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
60 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
61 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
62 };
63 void setup()
64 {
67 OLED.drawBitmap(20,10,logo,56,56,1);
68 OLED.display();
69 }
70 void loop()
71 {
72 delay(250);
73 }
- บรรทัดที่ 5-62 ตัวแปรที่ใช้เก็บรู ปภาพ
- บรรทัดที่ 67 วาดรู ปภาพจากตัวแปรเก็บรู ปภาพ
2. ทดลองเปลี่ยนรู ปภาพในการแสดงผล

1. เขียนโปรแกรมแสดงรู ปภาพ (เป็ นรู ปภาพที่เลื อกเองตามต้องการ) พร้ อมแสดงข้อความ
ประกอบและเวลาที่บอร์ ดเปิ ดใช้งานผ่านมา (หน่วยเป็ นวินาที) วงจรที่ใช้ทดลองเป็ นดังรู ป
ARDUINO
VCC VCC
A4(SDA)
A5(SCL)
VCC GND SCL SDA
GND

ใบงานที่ 4.22 การประยุกต์การแสดงผลที่ LCD 4 bit กับเซนเซอร์ต่าง ๆ  275
การประยุกต์ การแสดงผลที่ LCD 4 bit กับเซนเซอร์ ต่าง ๆ
เพื่อให้สามารถประยุกต์การแสดงผลที่ LCD 4 bit กับเซนเซอร์ ต่าง ๆ ได้
1. บอกวิธีประยุกต์การแสดงผลที่ LCD 4 bit กับเซนเซอร์ ต่าง ๆ ได้
2.1 Trim pot 10k 1 ตัว 2.5 LED 3mm 4 ตัว
2.2 Potentiometer 10k 1 ตัว 2.6 ตัวท้านทาน 220 4 ตัว
2.3 Thermistor NTC 10k 1 ตัว 2.7 ตัวท้านทาน 4.7k 1 ตัว
2.4 IC DS18B20 1 ตัว 2.8 ตัวท้านทาน 10k 1 ตัว
3. อุปกรณ์ร่วมอื่น ๆ
3.1 บอร์ ด Arduino Nano 3.0 1 ตัว 3.5 สายเชื่อมต่อ USB (Mini) 1 เส้น
3.2 LCD ชนิดตัวอักษร 16×2 1 ตัว 3.6 สายเชื่อมต่อวงจร 1 ชุด
3.3 โมดูลวัดอุณหภูมิ DHT22 1 ตัว 3.7 คอมพิวเตอร์ 1 เครื่ อง
3.4 โมดูลอัลตร้าโซนิค HC-SR04 1 ตัว
การประยุกต์ใช้งานในใบงานนี้ เป็ นการเปลี่ ยนเป้ าหมายการแสดงผลจากเดิ มในใบงานที่ 4.6,
4.7, 4.8, 4.9 และ 4.10 ที่เป็ นการอ่านค่าจากเซนเซอร์ แบบต่าง ๆ แล้วนาผลมาคานวณ (หรื อนามาใช้ได้
เลยในบางใบงาน) ไปแสดงผลผ่านทางจอคอมพิวเตอร์ ผ่านทางการสื่ อสารทางพอร์ ตอนุ กรมซึ่ ง การ
ดาเนิ นการดัง กล่ า วเป็ นการเขี ยนโค้ดโปรแกรมเพื่ อใช้ท ดสอบผลการท างานกับ เซนเซอร์ ต่า ง ๆ ใน
เบื้องต้นซึ่ งไม่ตอ้ งต่อตัวแสดงผลอื่น ๆ สาหรับใบงานนี้ เป็ นการเปลี่ ยนเป้ าหมายจากการแสดงผลจาก
จอคอมพิวเตอร์มาเป็ นจอ LCD ชนิดตัวอักษรที่ต่อเชื่อมแบบ 4 บิต
วงจรเพื่อใช้ทดลองในใบงานเป็ นการทดลองจากเซนเซอร์ ท้ งั 5 แบบโดยแสดงผลที่จอ LCD
ชนิดตัวอักษรที่เชื่ อมต่อแบบ 4 บิต วงจรที่ใช้ทดลองมีดงั นี้
1. วงจรที่ใช้เซนเซอร์ เป็ นตัวต้านทานปรับค่าได้
2. วงจรที่ใช้เซนเซอร์เป็ นเทอร์ มิสเตอร์วดั อุณหภูมิที่อ่านค่ามาเป็ นแรงดันแอนาลอก
3. วงจรที่ใช้เซนเซอร์เป็ น DHT22
4. วงจรที่ใช้เซนเซอร์เป็ น Ultrasonic
5. วงจรที่ใช้เซนเซอร์เป็ น DS18B20
วงจรทีใ่ ช้ เซนเซอร์ เป็ นตัวต้ านทานปรับค่ าได้

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1 4 11
D2 D4
0.1uF 5 12
D3 D5
6 13
D4 D6
11 14
D5 D7
R2,R3
RXD D1(TXD)
2 12 6 5 4 3 2 1
TXD D0(RXD) D6
+5V VCC
GND 13
3V3 D7
10k
VCC
X1 28
16MHz 9 A5 10k
XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


VCC ARDUINO
11
5V D2 D4
12
D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
VCC
A5 10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
D13
3V3
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 1 เขียนโปรแกรมแสดงค่าที่อ่านได้จากโพเทนธิ โอมิเตอร์

START
กา นดค่าเริ ่มต้ นต่ าง ๆ

2 /* The circuit:
10 */
11 #define POT 5
13 void setup()
14 {
16 lcd.print("Analog Read :");
17 }
18 void loop()
19 {
22 lcd.print(adc);
23 delay(100);
24 }
3. ทดลองเปลี่ยนแปลงค่าโพเทนธิ โอมิเตอร์ แล้วสังเกตผล
วงจรทีใ่ ช้ เซนเซอร์ เป็ นเทอร์ มสิ เตอร์ วดั อุณ ภูมิ

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1 4 11
D2 D4
0.1uF 5 12
D3 D5
6 13
D4 D6
11 14
D5 D7
R2,R3
RXD D1(TXD)
2 12 6 5 4 3 2 1
TXD D0(RXD) D6
+5V VCC
GND 13
3V3 D7
10k
VCC
R4
X1 10k
16MHz 9 28
XTAL1 A5
10 XTAL2 NTC
T
Thermistor
C2,C3 GND 10k
22pF 8,22

VCC ARDUINO
11
5V D2 D4
12
D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
VCC
R1
10k
A5
NTC
T
Thermistor
GND 10k

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
D13
3V3
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 2 เขียนโปรแกรมแสดงผลที่อ่านค่าจากเทอร์ มิสเตอร์ แล้วคานวนเป็ นอุณหภูมิ

START
กา นดค่าเริ ่มต้ นต่ า ง ๆ
คานวณ
แสดงผล

2 /* The circuit:
10 */
11 #define NTC A5
14 void setup()
15 {
17 lcd.print("Temperature is:");
19 lcd.print("'C");
20 }
21 void loop()
22 {
25 lcd.print(Temp);
26 delay(500);
27 }
29 {
30 double Cal;
31 Cal = log(10000.0/((1024.0/RawADC-1)));
32 Cal = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Cal * Cal))* Cal);
34 return Cal;
35 }
3. ทดลองเพิ่ม/ลดอุณหภูมิที่เทอร์ มิสเตอร์ สังเกตผล
วงจรทีใ่ ช้ เซนเซอร์ เป็ น DHT22
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1 4 11
D2 D4
0.1uF 5 12
D3 D5
6 13
D4 D6
11 14
D5 D7
R2,R3
RXD D1(TXD)
2 12 6 5 4 3 2 1
TXD D0(RXD) D6
+5V VCC
GND 13
3V3 D7
10k
VCC
R4 DHT22
4k7
X1
16MHz 9 D8 14 DATA
XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
11
5V D2 D4
12
D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
VCC
R1 DHT22
4k7
D8 DATA
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
D13
3V3
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1
การทดลองที่ 3 เขียนโปรแกรมแสดงอุณภูมิและความชื้นจาก DHT22

START
แสดงผล

2 /* The circuit:

10 */
11 #include <DHT.h>
16 void setup()
17 {
19 lcd.print("Humidity:");
21 lcd.print("Temp:");
22 dht.begin();
23 }
24 void loop()
25 {
26 delay(2000);
30 {
31 lcd.clear();
32 lcd.print("Failed read DHT");
33 return;
34 }
36 lcd.print(h);
38 lcd.print(t);
39 }
3. ทดลองเพิ่ม/ลดอุณหภูมิและความชื้น สังเกตผล
วงจรทีใ่ ช้ เซนเซอร์ เป็ น Ultasonic

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC 4 11
RST D2 D4
C1 5 12
D3 D5
0.1uF 6 13
D4 D6
11 14
D5 D7
R2,R3 E R/W RS Vo VCC GND

3 12 6 5 4 3 2 1
DTR
RXD D1(TXD) D6 VCC
2 13
TXD D0(RXD) D7
+5V
GND
3V3 10k
VCC
1
VCC
HC-SR04
X1 15 2
16MHz 9 D9 Trig
XTAL1 14 3
10 XTAL2 D8 Echo
4
C2,C3 GND GND
22pF 8,22


VCC ARDUINO
11
D2 D4
12
5V D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
Echo
Trig
VCC
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
HC-SR04
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 4 เขียนโปรแกรมวัดระยะด้วย Ultrasonic แสดงผลด้วยจอ LCD

START
อ่ านค่าจากโมดูล Ultrasonic
แสดงผล

2 /* The circuit:
10 */
14 void setup()
15 {
17 lcd.print("Length is :");
19 lcd.print("cm");
20 }
21 void loop()
22 {
23 delay(500);
25 float L=ultrasonic.Ranging(CM);
26 lcd.print(L);
27 }
วงจรทีใ่ ช้ เซนเซอร์ เป็ น DS18B20

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC 4 11
RST D2 D4
C1 5 12
D3 D5
0.1uF 6 13
D4 D6
11 14
D5 D7
R2,R3 E R/W RS Vo VCC GND

3 12 6 5 4 3 2 1
DTR
RXD D1(TXD) D6 VCC
2 13
TXD D0(RXD) D7
+5V
GND
3V3 10k
R4 R5
4.7k VCC 4.7k VCC
3 DS18B20 3 DS18B20
D8
14 2 DQ VCC 2 DQ VCC
X1 15 GND GND
16MHz D9
9 XTAL1 1 1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
11
5V D2 D4
12
D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
10k
R1 R2
4.7k VCC 4.7k VCC
3 DS18B20 3 DS18B20
D8 2 DQ VCC 2 DQ VCC
D9 GND GND
1 1
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
GND
RST
REF
VIN
D13
3V3
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D S1 8 D S1 8
B 20 B 20
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 5 เขียนโปรแกรมแสดงค่าอุณหภูมิที่วดั จากไอซี DS18B20 จานวน 2 ตัวโดยแสดงผลที่จอ

LCD ที่เชื่อมต่อแบบ 4 บิต
START

10 void temp_read();
11 LiquidCrystal lcd(7,6,2,3,4,5); // 7->RS,6->E,2->D4,3->D5,4->D6,5->D7
12 void setup()
13 {
15 lcd.print("Sensor1: 'C");
20 }
21 void loop()
22 {
23 temp_read();
25 lcd.print(temp_1,1);
28 delay(500);
29 }
30 void temp_read()
31 {
34 //------------------------------------------
37 }
10. งานทีม่ อบ มาย

1. เขี ย นโปรแกรมที่ ใ ช้ เ ซนเซอร์ ว ดั อุ ณ หภู มิ แ ละความชื้ น DHT22 โดยใช้ ค่ า อุ ณ ภู มิ แ ละ
ความชื้นเป็ นตัวควบคุมการทางานของ LED พร้อมทั้งแสดงผลที่จอ LCD
VCC ARDUINO
11
D2 D4
12
5V D3 D5
13
D4 D6
14
D5 D7
E R/W RS Vo VCC GND

6 5 4 3 2 1
D6 VCC
D7
R1-R4 220
D10 10k
D11
D12
D13 VCC
LED1-LED4
R5 DHT22
4k7
D8 DATA
GND

ใบงานที่ 4.23 การประยุกต์การแสดงผลที่ LCD I2C กับเซนเซอร์ตา่ ง ๆ  289
การประยุกต์ การแสดงผลที่ LCD I2C กับเซนเซอร์ ต่าง ๆ
เพื่อให้สามารถประยุกต์การแสดงผลที่ LCD I2C กับเซนเซอร์ ต่าง ๆ ได้
1. บอกวิธีประยุกต์การแสดงผลที่ LCD I2C กับเซนเซอร์ ต่าง ๆ ได้
2.1 Potentiometer 10k 1 ตัว 2.5 ตัวท้านทาน 220 ohm 4 ตัว
3.1 บอร์ ด Arduino Nano 3.0 1 ตัว 3.5 โมดูลอัลตร้าโซนิค HC-SR04 1 ตัว
3.2 LCD ชนิดตัวอักษร 16x2 1 ตัว 3.6 สายเชื่อมต่อ USB (Mini) 1 เส้น
3.3 โมดูล I2C สาหรับ LCD 1 ตัว 3.7 สายเชื่อมต่อวงจร 1 ชุด
จอคอมพิวเตอร์มาเป็ นจอ LCD ชนิดตัวอักษรที่ต่อเชื่อมแบบ I2C ผ่านทางโมดูลสื่ อสาร
วงจรเพื่อใช้ทดลองในใบงานเป็ นการทดลองจากเซนเซอร์ ท้ งั 5 แบบโดยแสดงผลที่จอ LCD
ชนิดตัวอักษรที่เชื่ อมต่อแบบ 4 บิต วงจรที่ใช้ทดลองมีดงั นี้

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
VCC
27 SDA
A4(SDA)
28 SCL
A5(SCL)
R2,R3 GND
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
X1
16MHz 9 XTAL1 26
A3 10k
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
VCC VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
VCC
A3 10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
GND
I
I
VCC
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
SDA
G
G
SCL
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

START

1 #include <Wire.h>
3 #define POT 3
5 void setup()
6 {
7 lcd.init();
8 lcd.backlight();
10 lcd.print("Analog Read :");
11 }
12 void loop()
13 {
16 lcd.print(adc);
17 delay(100);
18 }
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
VCC
27 SDA
A4(SDA)
28 SCL
A5(SCL)
R2,R3 GND
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
R4
X1 10k
16MHz 9 26
XTAL1 A3
10 XTAL2 NTC
T
Thermistor
C2,C3 GND 10k
22pF 8,22


ARDUINO
VCC VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
VCC
R1
10k
A3
NTC
T
Thermistor
10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
GND
I
I
VCC
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
SDA
G
G
SCL
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1


START
คานวณ
แสดงผล

1 #include <Wire.h>
3 #define NTC A3
5 LiquidCrystal_I2C lcd(0x3F,16,2); // 0x27 for PCF8574 and 0x3F for PCF8574A
6 void setup()
7 {
8 lcd.init();
9 lcd.backlight();
11 lcd.print("Temperature is:");
13 lcd.print("'C");
14 }
15 void loop()
16 {
19 lcd.print(Temp);
20 delay(500);
21 }
23 {
24 double Cal;
25 Cal = log(10000.0/((1024.0/RawADC-1)));
26 Cal = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Cal * Cal))* Cal);
28 return Cal;
29 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
VCC
27 SDA
A4(SDA)
28 SCL
A5(SCL)
R2,R3 GND
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
R4 DHT22
4k7
X1
16MHz 9 XTAL1 D8 14 DATA
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
VCC VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
VCC
R1 DHT22
4k7
D8 DATA
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
GND
I
VCC
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
SDA
G
SCL
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1


START
แสดงผล

1 #include <Wire.h>
3 #include <DHT.h>
8 void setup()
9 {
10 lcd.init();
11 lcd.backlight();
13 lcd.print("Humidity:");
15 lcd.print("Temp:");
16 dht.begin();
17 }
18 void loop()
19 {
20 delay(2000);
24 {
25 lcd.clear();
26 lcd.print("Failed read DHT");
27 return;
28 }
30 lcd.print(h);
32 lcd.print(t);
33 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST VCC
C1 VCC
0.1uF 27 SDA
A4(SDA)
28 SCL
A5(SCL)
GND
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
1
VCC
HC-SR04
15 2
D9 Trig
X1 14 3
16MHz 9 D8 Echo
XTAL1 4
10 XTAL2 GND
C2,C3 GND
22pF 8,22

ARDUINO VCC
VCC GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
GND
I
I
VCC
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
SDA
GND
Echo
Trig
VCC
G
G
SCL
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
HC-SR04
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

START
แสดงผล

1 #include <Wire.h>
6 void setup()
7 {
8 lcd.init();
9 lcd.backlight();
11 lcd.print("Length is :");
13 lcd.print("cm");
14 }
15 void loop()
16 {
17 delay(500);
20 lcd.print(L);
21 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
VCC
27 SDA
A4(SDA)
28 SCL
A5(SCL)
R2,R3 GND
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
R4 R5
4.7k VCC 4.7k VCC
3 DS18B20 3 DS18B20
D8
X1 15 GND GND
16MHz D9
9 XTAL1 1 1
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
VCC VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
R1 R2
4.7k VCC 4.7k VCC
3 DS18B20 3 DS18B20
D9 GND GND
1 1
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
GND
I
I
VCC
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
SDA
G
G
SCL
F
F
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
D S1 8 D S1 8
B 20 B 20
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 5 เขียนโปรแกรมแสดงค่าอุณหภูมิที่วดั จากไอซี DS18B20 จานวน 2 ตัวโดยแสดงผลที่จอ

LCD ที่เชื่อมต่อผ่านทางโมดูล I2C
START

1 #include <Wire.h>
13 void setup()
14 {
21 }
22 void loop()
23 {
24 temp_read();
29 delay(500);
30 }
31 void temp_read()
32 {
35 //------------------------------------------
38 }
1. ออกแบบโจทย์ประยุกต์ใช้งานที่ใช้เซนเซอร์ วดั อุณหภูมิและความชื้ น DHT22 แสดงผลการ
ทางานที่จอ LCD I2C
ARDUINO
VCC VCC
GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
R1-R4 220
D10
D11
D12
D13 VCC
LED1-LED4
R5 DHT22
4k7
D8 DATA
GND
2. ออกแบบโจทย์ประยุกต์ใช้งานที่ใช้เซนเซอร์ วดั ระยะทาง Ultrasonic แสดงผลการทางานที่

จอ LCD I2C
ARDUINO VCC
VCC GND
VCC
SDA
SCL
A4(SDA)
A5(SCL)
R1-R4 220
D10
D11
D12
D13
LED1-LED4 VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

ใบงานที่ 4.24 การประยุกต์การแสดงผลด้วยโมดูล MAX7219 กับเซนเซอร์ต่าง ๆ  303
การประยุกต์ การแสดงผลด้ วยโมดูล MAX7219 กับเซนเซอร์ ต่าง ๆ
เพื่อให้สามารถประยุกต์การแสดงผลด้วยโมดูล MAX7219 กับเซนเซอร์ ต่าง ๆ ได้
1. บอกวิธีประยุกต์การแสดงผลด้วยโมดูล MAX7219 กับเซนเซอร์ ต่าง ๆ ได้
3.2 โมดูลตัวเลข MAX7219 1 ตัว 3.6 สายเชื่อมต่อวงจร 1 ชุด
จอคอมพิวเตอร์มาแสดงผลที่โมดูลตัวเลข MAX7219
วงจรเพื่ อใช้ท ดลองในใบงานเป็ นการทดลองจากเซนเซอร์ ท้ งั 5 แบบโดยแสดงผลที่ โมดู ล
แสดงผลตัวเลข MAX7219 วงจรที่ใช้ทดลองมีดงั นี้
2. วงจรที่ใช้เซนเซอร์ เป็ นเทอร์ มิสเตอร์ วดั อุณหภูมิที่อ่านค่ามาเป็ นแรงดันแอนนาลอก

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC VCC
C1 VCC
0.1uF 17
D11(MOSI) Din
16
D10(SS) Load
19
D13(SCK) Clk
GND
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND VCC
3V3
28
A5 10k
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


VCC ARDUINO
5V
VCC
VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
VCC
A5 10k
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
VCC
GND
F
F
DIN
CS
GND
RST
REF
VIN
3V3
D13
CLK
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1


START

2 #include "SPI.h"
3 #define POT 5
4 HCMAX7219 HCMAX7219(10); /* D10 -> CS pin */
5 void setup()
6 {
7 HCMAX7219.Intensity(10, 0); /*Sets the intensity of the LED 0 to 15 */
8 }
9 void loop()
10 {
12 HCMAX7219.Clear(); /* Clear the output buffer */
13 HCMAX7219.print7Seg(adc,4); /* Write value to the output buffer */
14 HCMAX7219.Refresh(); /* Send the output buffer to the display */
15 delay(100);
16 }
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC VCC
C1 VCC
0.1uF 17
D11(MOSI) Din
16
D10(SS) Load
19
D13(SCK) Clk
GND
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V VCC
GND
3V3
R4
10k
28
A5
NTC
T
Thermistor
10k
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22


VCC ARDUINO
5V
VCC
VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
VCC
R1
10k
A5
NTC
T
Thermistor
10k
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
VCC
GND
F
F
DIN
CS
GND
RST
REF
VIN
3V3
D13
CLK
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1


START
คานวณ
แสดงผล

2 #include "SPI.h"
3 #define NTC A5
6 void setup()
7 {
9 }
10 void loop()
11 {
14 HCMAX7219.print7Seg(Temp*10,1,5); /* Write value to the output buffer */
15 HCMAX7219.print7Seg("'C",2); /* Write "'C" to the output buffer */
17 delay(100);
18 }
20 {
21 double Cal;
22 Cal = log(10000.0/((1024.0/RawADC-1)));
23 Cal = 1/(0.001129148+(0.000234125 + (0.0000000876741 * Cal * Cal))* Cal);
25 return Cal;
26 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC VCC
C1 VCC
0.1uF 17
D11(MOSI) Din
16
D10(SS) Load
19
D13(SCK) Clk
GND
R2,R3
DTR 3
RXD D1(TXD)
2 VCC
TXD D0(RXD)
+5V
GND
3V3
R4 DHT22
4k7
D8 14 DATA
X1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
5V
VCC
VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
VCC
R1 DHT22
4k7
D8 DATA
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
VCC
GND
F
DIN
CS
GND
RST
REF
VIN
3V3
D13
CLK
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1


START
แสดงผล

2 #include "SPI.h"
3 #include <DHT.h>
8 void setup()
9 {
11 dht.begin();
12 }
13 void loop()
14 {
15 delay(2000);
20 {
21 HCMAX7219.print7Seg("FALT",8); /* Write "FALT" to the output buffer */
22 return;
23 }
24 HCMAX7219.print7Seg(h*10,1,8); /* Write value to the output buffer */
25 HCMAX7219.print7Seg(t*10,1,4); /* Write value to the output buffer */
27 }
3. ทดลองเพิม่ /ลดอุณหภูมิและความชื้น สังเกตผล

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC VCC
C1 VCC
0.1uF 17
D11(MOSI) Din
16
D10(SS) Load
19
D13(SCK) Clk
GND
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3 VCC
1
VCC
HC-SR04
15 2
D9 Trig
14 3
D8 Echo
4
X1 GND
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
5V
VCC
VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
VCC
GND
F
F
DIN
GND
Echo
Trig
VCC
CS
GND
RST
REF
VIN
3V3
D13
CLK
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
C
C
HC-SR04
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1

START
แสดงผล

2 #include "SPI.h"
6 void setup()
7 {
9 }
10 void loop()
11 {
12 delay(500);
15 HCMAX7219.print7Seg(L,8); /* Write value to the output buffer */
16 HCMAX7219.print7Seg("CM",5); /* Write value to the output buffer */
18 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC VCC
C1 VCC
0.1uF 17
D11(MOSI) Din
16
D10(SS) Load
19
D13(SCK) Clk
GND
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3 R4 R5
4.7k VCC 4.7k VCC
3 DS18B20 3 DS18B20
D8
D9 15 GND GND
X1
1 1
16MHz 9 XTAL1
10 XTAL2
C2,C3 GND
22pF 8,22

VCC ARDUINO
VCC
5V VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
R1 R2
4.7k VCC 4.7k VCC
3 DS18B20 3 DS18B20
D9 GND GND
1 1
GND

15
40
60
10
20
25
30
35
45
50
55
1
5
J
J
I
I
G H
G H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
VCC
GND
F
F
DIN
CS
GND
RST
REF
VIN
3V3
D13
CLK
A0
A2
A4
A1
A3
A5
A6
A7
5V
D E
D E
D S1 8 D S1 8
B 20 B 20
C
C
B
B
A
A
15
40
60
10
20
25
30
35
45
50
55
1
ปัญ าการจาลองการทางานของไลบรารี่ DallasTemperature.h

ในใบงานที่ผา่ นมาการจาลองการทางานสามารถจาลองได้ปกติไม่มีขอ้ ผิดพลาดใด ๆ แต่สาหรับ
ใบงานนี้ หากใช้ไลบรารี่ DallasTemperature.h เพื่ออ่านค่าอุณหภูมิจากไอซี DS18B20 จะไม่สามารถอ่าน
ค่าได้แม้วา่ โค้ดนั้นสามารถทดลองในวงจรจริ งได้ก็ตาม ทั้งนี้เกิดจากเวอร์ ชนั่ ของโปรแกรม Arduino IDE
ซึ่ งถ้าหากต้องการที่จะจาลองการทางานเพื่อดูผลการทางานจะต้องไปใช้เวอร์ ชนั่ 1.6.5
(a) เมื่อใช้ Arduino IDE V. 1.8.3 (b) เมื่อใช้ Arduino IDE V. 1.6.5
รู ปที่ 4.24-20 ผลการทดลองในโปรแกรมจาลองการทางานจาก Arduino IDE ต่างเวอร์ ชนั่
การทดลองที่ 5 เขี ยนโปรแกรมแสดงค่าอุ ณหภู มิที่วดั จากไอซี DS18B20 จานวน 2 ตัวโดยแสดงผลที่

โมดูลตัวเลข MAX7219
START

2 #include <SPI.h>
13 void setup()
14 {
18 }
19 void loop()
20 {
21 temp_read();
23 HCMAX7219.print7Seg(temp_1*10,1,8); /* Write value to the output buffer */
24 HCMAX7219.print7Seg(temp_2*10,1,4); /* Write value to the output buffer */
25 HCMAX7219.Refresh(); /* Send the output buffer to display */
26 delay(100);
27 }
28 void temp_read()
29 {
32 //------------------------------------------
35 }
1. ออกแบบโจทย์ประยุกต์ใช้งานที่ใช้เซนเซอร์ วดั อุณหภูมิและความชื้ น DHT22 แสดงผลการ
ทางานที่โมดูลตัวเลข MAX7219
VCC ARDUINO
VCC
5V VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
R1-R4 220
D2
D3
D4
VCC
D5
LED1-LED4
R5 DHT22
4k7
D8 DATA
GND
2. ออกแบบโจทย์ประยุกต์ใช้งานที่ใช้เซนเซอร์ วดั ระยะทาง Ultrasonic แสดงผลการทางานที่

โมดูลตัวเลข MAX7219
VCC ARDUINO
VCC
5V VCC
D11(MOSI) Din
D10(SS) Load
D13(SCK) Clk
GND
R1-R4 220
D2
D3
D4
D5
LED1-LED4
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

ใบงานที่ 4.25 การประยุกต์การแสดงผลที่ OLED กับเซนเซอร์ต่าง ๆ  317
การประยุกต์ การแสดงผลที่ OLED กับเซนเซอร์ ต่าง ๆ
เพื่อให้สามารถประยุกต์การแสดงผลที่ OLED กับเซนเซอร์ ต่าง ๆ ได้
1. บอกวิธีประยุกต์การแสดงผลที่ OLED กับเซนเซอร์ ต่าง ๆ ได้
3.2 โมดูลจอ OLED (SSD1306) 1 ตัว 3.6 สายเชื่อมต่อวงจร 1 ชุด
เบื้องต้นซึ่ งไม่ตอ้ งต่อตัวแสดงผลอื่น ๆ สาหรับใบงานนี้ เป็ นการเปลี่ยนเป้ าหมายจากการแสดงผลจาก
จอคอมพิวเตอร์มาเป็ นจอ OLED
วงจรเพื่อใช้ทดลองในใบงานเป็ นการทดลองจากเซนเซอร์ ท้ งั 5 แบบโดยแสดงผลที่จอ OLED
วงจรที่ ใ ช้ท ดลองมี ดัง นี้ (OLED ไม่ ส ามารถจาลองการท างานด้วย Proteus ได้ต้องทดลองวงจรจริ ง
เท่านั้น)

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1 VCC
1 AVCC
RST 27
C1 A4(SDA)
0.1uF 28
A5(SCL)
R2,R3 VCC GND SCL SDA

DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
X1
16MHz 9 XTAL1 26
A3 10k
10 XTAL2
C2,C3 GND
22pF 8,22


ARDUINO
VCC
VCC
A4(SDA)
A5(SCL)
VCC VCC GND SCL SDA
A3 10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

START

1 #include <Wire.h>
4 int adc;
6 void setup()
7 {
8 OLED.begin(SSD1306_SWITCHCAPVCC,0x3C);
9 }
10 void loop()
11 {
12 adc=analogRead(A3);
17 OLED.println("Analog");
18 OLED.print("Read");
20 OLED.print(adc,DEC);
21 OLED.display();
22 delay(200);
23 }
VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF
VCC
27
A4(SDA)
28
A5(SCL)
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V VCC GND SCL SDA
GND
3V3
VCC
R4
X1 10k
16MHz 9 26
XTAL1 A3
10 XTAL2 NTC
T
Thermistor
C2,C3 GND 10k
22pF 8,22

ARDUINO
VCC
VCC
A4(SDA)
A5(SCL)
VCC
R1 VCC GND SCL SDA

10k
A3
NTC
T
Thermistor
10k
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

START
คานวณ
แสดงผล

1 #include <Wire.h>
4 #define NTC A3
7 void setup()
8 {
10 }
11 void loop()
12 {
18 OLED.println("Temperature");
19 OLED.print("From NTC");
21 OLED.print(Temp);
22 OLED.display();
23 delay(200);
24 }
26 {
27 double Cal;
28 Cal = log(10000.0/((1024.0/RawADC-1)));
29 Cal = 1/(0.001129148+(0.000234125+(0.0000000876741*Cal*Cal))*Cal );
30 Cal = Cal-273.15; // Convert Kelvin to Celcius
31 return Cal;
32 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1 VCC
1 AVCC
RST 27
C1 A4(SDA)
0.1uF 28
A5(SCL)
R2,R3 VCC GND SCL SDA

DTR 3
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
R4 DHT22
4k7
X1
16MHz 9 XTAL1 D8 14 DATA
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
VCC
VCC
A4(SDA)
A5(SCL)
VCC GND SCL SDA
VCC
R1 DHT22
4k7
D8 DATA
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
F
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

START
แสดงผล

1 #include <Wire.h>
4 #include <DHT.h>
9 void setup()
10 {
14 dht.begin();
15 }
16 void loop()
17 {
18 delay(2000);
23 {
26 OLED.println("Failed read DHT !");
27 OLED.display();
28 return;
29 }
31 OLED.print("Humidity: ");
32 OLED.print(h);
34 OLED.print("Temperature: ");
35 OLED.print(t);
36 OLED.display();
37 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST VCC
C1
0.1uF 27
A4(SDA)
28
A5(SCL)
R2,R3
DTR 3 VCC GND SCL SDA
RXD D1(TXD)
2
TXD D0(RXD)
+5V
GND
3V3
VCC
1
VCC
HC-SR04
15 2
D9 Trig
X1 14 3
16MHz 9 D8 Echo
XTAL1 4
10 XTAL2 GND
C2,C3 GND
22pF 8,22

ARDUINO
VCC
VCC
A4(SDA)
A5(SCL)
VCC GND SCL SDA
VCC
1
VCC
HC-SR04
2
D9 Trig
3
D8 Echo
4
GND
GND

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D8
D7
D6
D5
D4
D3
D2
D0
D1
GND
D11
D10
GND
Echo
Trig
VCC
G
G
F
F
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A1
A2
A3
A4
A5
A6
A7
5V
E
E
HC-SR04
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1
การทดลองที่ 4 เขียนโปรแกรมวัดระยะด้วย Ultrasonic แสดงผลด้วยจอ OLED

START
แสดงผล

1 #include <Wire.h>
7 void setup()
8 {
11 }
12 void loop()
13 {
15 delay(500);
19 OLED.println("Distance measurable");
20 OLED.print("From Ultrasonic");
23 OLED.print(L);
24 OLED.print(" CM.");
25 OLED.display();
26 }

VCC

1N5819
R1
10k 7,20 ATMEGA328
VCC
SW1
1 AVCC
RST
C1
0.1uF VCC
27
A4(SDA)
28
A5(SCL)
R2,R3
DTR 3
RXD D1(TXD)
2
TXD D0(RXD) VCC GND SCL SDA
+5V
GND
3V3
R4
4.7k VCC
3 DS18B20
D8
14 2 DQ VCC
X1 GND
16MHz 9 XTAL1 1
10 XTAL2
C2,C3 GND
22pF 8,22

ARDUINO
VCC
VCC
A4(SDA)
A5(SCL)
R1
4.7k VCC VCC GND SCL SDA
3 DS18B20
D8 2 DQ VCC
GND
GND 1

10
15
20
25
30
35
40
45
50
55
60
1
5
J
J
I
I
H
H
D12
RST
D9
D7
D5
D1
D8
D6
D4
D3
D2
D0
GND
D11
D10
G
G
F
B 20
D S1 8
VCC GND S CL S DA
GND
RST
REF
VIN
3V3
D13
A0
A2
A4
A1
A3
A5
A6
A7
5V
E
E
D
D
C
C
B
B
A
A
10
15
20
25
30
35
40
45
50
55
60
1

การทดลองที่ 5 เขียนโปรแกรมแสดงค่าอุณหภูมิที่วดั จากไอซี DS18B20 โดยแสดงผลที่จอ OLED

START

1 #include <Wire.h>
6 OneWire ds(8); //sensor on pin D8
7 DallasTemperature sensor(&ds);
9 void setup()
10 {
13 sensor.begin();
14 }
15 void loop()
16 {
17 sensor.requestTemperatures();
18 float temp = sensor.getTempCByIndex(0); //read temp from sensor
19 delay(500);
23 OLED.println("Temperature");
24 OLED.print("From DS18B20");
27 OLED.print(temp);
28 OLED.print(" 'C");
29 OLED.display();
30 }
1. เขียนโปรแกรมประยุกต์ใช้งานที่ใช้เซนเซอร์ วดั อุณหภูมิ DS18B20 และควบคุมการทางาน
ของ LED ตามค่าของอุณหภูมิที่กาหนดโดยแสดงผลการทางานที่จอ OLED
ARDUINO
VCC VCC
A4(SDA)
A5(SCL)
R1-R2
220
LED1-LED2
D2
VCC GND SCL SDA
D3
R3
4.7k VCC
3 DS18B20
D8 2 DQ VCC
GND
1
GND
2. เขียนโปรแกรมรับค่าจากพอร์ ตแอนาลอกโดยให้แสดงผลที่จอ OLED เป็ นโวลต์มิเตอร์ แบบ

เข็มโดยมีค่าแรงดันเต็มหน้าปั ด (Full scale) ที่ 30V
ARDUINO
VCC
VCC
A4(SDA)
A5(SCL)
VCC VCC GND SCL SDA
A3 10k
GND

เรี ยนรู ้และลองเล่น Arduino เบื้องต้น  329
บรรณานุกรม
- Brian Evans Beginning Arduino Programming

- Jonathan Oxer,Hugh Blemings Practical Arduino Cool Projects for Open Source Hardware
- Michael Margolis Arduino Cookbook : O’Reilly Media, Inc
- Julien Bayle C Programming for Arduino
- Alan G. Smith Introduction to Arduino
- Maik Schmidt Arduino A Quick-Start Guide
330  เรี ยนรู ้และลองเล่น Arduino เบื้องต้น [ครู ประภาส สุ วรรณเพชร]
ภาคผนวก
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อลงโปรโต้บอร์ ด
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อแผงทดลองที่สร้างแผ่นวงจรพิมพ์ดว้ ยตัวเอง
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อแผงทดลองที่สร้างแผ่นวงจรพิมพ์โดยสั่งโรงงานผลิต
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อลงแผ่นวงจรพิมพ์เอนกประสงค์
เรี ยนรู ้และลองเล่น Arduino เบื้องต้น  331
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อลงโปรโต้บอร์ ด
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อแผงทดลองที่สร้างแผ่นวงจรพิมพ์ดว้ ยตัวเอง
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อแผงทดลองที่สร้างแผ่นวงจรพิมพ์โดยสั่งโรงงานผลิต
332  เรี ยนรู ้และลองเล่น Arduino เบื้องต้น [ครู ประภาส สุ วรรณเพชร]
ภาพตัวอย่างวงจรที่ใช้ทดลองที่ต่อลงแผ่นวงจรพิมพ์เอนกประสงค์
ต้นแบบลายวงจรพิมพ์และรายละเอียดการสร้างตลอดจนรายการอุปกรณ์ ผูท้ ี่สนใจสามารถนาไป

สร้างได้ดว้ ยตนเองโดยเข้าไปที่เวปไซต์ของครู ประภาส www.praphas.com เข้าเมนู “งานที่มอบหมาย” แล้ว
คลิกไปที่ “ไมโครคอนโทรลเลอร์ (Arduino)”

Arduino Book

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Arduino Book

Uploaded by

Copyright:

Available Formats

เรียนรู้และลองเล่น

เรียนรู้และลองเล่น Arduino เบื้องต้ น

สงวนลิขสิ ทธิ์ สำหรับกำรพิมพ์เพื่อจำหน่ำย © โดยครู ประภำส สุ วรรณเพชร

หากพบเจอข้ อผิดพลาดใด ๆ ในหนังสื อเล่มนี้

หนังสื อเล่มนี้ จดั ไว้สำหรับกำรพิมพ์สองด้ำนหน้ำกระดำษ

ครู ประภำส สุ วรรณเพชร

เอกสารเล่มนี้ ขา้ พเจ้าได้เรี ยบเรี ยงขึ้ นจากประสบการณ์ ที่สอนนักศึกษาเป็ นเวลากว่า 25 ปี ได้

เอกสารประกอบการสอนเล่มนี้ ขา้ พเจ้าได้พากเพียรค้นคว้าพัฒนาปรับปรุ งให้มีความสมบู รณ์

ความรู้ เบื้องต้ นเกีย่ วกับไมโครคอนโทรลเลอร์

Mechanical Engineering, เอกสารประกอบการอบรมค่ ายหุ่นยนต์ ปลาครั้งที่ 2, หน้า 1.

ตัวเลขที่ใช้อยูใ่ นปั จจุบนั ซึ่ งเรี ยกว่าตัวเลขฮินดูอาระบิกนี้ ใช้แทนด้วยตัวเลข 10 ตัวคือ 1, 2, 3, 4,

การแปลงเลขฐาน 10 เป็ นเลขใด ๆ

ตัวอย่าง การแปลงเลขฐาน 10 เป็ นเลขฐาน 2

ตัวอย่าง การแปลงเลขฐาน 10 เป็ นเลขฐาน 3

ตัวอย่าง การแปลงเลขฐาน 10 เป็ นเลขฐาน 4

การแปลงเลขฐานใด ๆ เป็ นเลขฐาน 10

ตัวอย่าง การแปลงเลขฐาน 8 เป็ นเลขฐาน 10

ตัวอย่าง การแปลงเลขฐาน 5 เป็ นเลขฐาน 10

ตัวอย่าง การแปลงเลขฐาน 2 เป็ นเลขฐาน 10

หากคานวณจากน้ าหนักในแต่ละตาแหน่งก่อนจะทาให้การหาค่าง่ายขึ้น ดังตัวอย่าง

ตัวอย่าง การแปลงเลขฐาน 2 ให้เป็ นเลขฐาน 16 โดยการแบ่งกลุ่มตัวเลข

ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 2 โดยการแบ่งกลุ่มตัวเลข

การแปลงเลขฐาน 10 เป็ นเลขฐาน 16

ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 โดยการแปลงเป็ นเลขฐาน 2 ก่อน

ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16

2. แปลงโดยตรงทาได้โดยการหารเช่นเดียวกับการแปลงเลขฐาน 2 เป็ นเลขฐาน 10 ต่างตรงที่ใช้ 16

ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 โดยการหาร

ตัวอย่าง การแปลงเลขฐาน 10 ให้เป็ นเลขฐาน 16 โดยการหาร

การแปลงเลขฐาน 16 เป็ นเลขฐาน 10

ในการแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 สามารถทาได้ 2 แนวทางคือ

ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 โดยการแปลงเป็ นเลขฐาน 2 ก่อน

ตัวอย่าง การแปลงเลขฐาน 16 ให้เป็ นเลขฐาน 10 โดยรวมจากน้ าหนักในแต่ละหลัก

1.2 ดิจิทลั พืน้ ฐาน

เหล่านี้เป็ นการอ้างแบบ Binary digital ดิจิทลั มีความเกี่ยวข้องกับไมโครคอนโทรลเลอร์ ท้ งั ฮาร์ ดแวร์ และ

รู ปที่ 1-1 ระดับแรงดันของลอจิก

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

แอนด์เกต (AND gate)

ออร์เกต (OR gate)

เอ็กซ์คลูซีฟออร์เกต (XOR gate)

น็อตเกต (NOT gate)

แนนด์เกต (NAND gate), นอร์เกต (NOR gate)

1.3 โครงสร้ างพืน้ ฐานของระบบคอมพิวเตอร์

อินพุต หน่วยประมวลผลกลาง เอาต์พุต

รู ปที่ 1-2 โครงสร้างพื้นฐานของระบบคอมพิวเตอร์

d) E2PROM คุณสมบัติ โปรแกรมเองได้หลายครั้งและลบได้ดว้ ยไฟฟ้า

1.4 ไมโครคอนโทรลเลอร์ Arduino

ฮาร์ ตแวร์ (Hardware)

ซอฟต์ แวร์ (Software)

ตัวอย่างบอร์ ด Arduino ที่นิยมนามาใช้งาน

รู ปที่ 1-5 บอร์ด Arduino Mega

ดร. ศรี ไพร ศักดิ์รุ่งไพรศาลกุล “หลักการเขียนโปรแกรม” http://www.gotoknow.org/blogs/posts/269964

ขั้นตอนวิธี หรื อ Algorithm (ภาษาไทย : อัลกอริ ทึม) หมายถึงกระบวนการแก้ปัญหาที่สามารถ

ตารางที่ 2-1 ผังงานหลักที่ใช้งานไมโครคอนโทรลเลอร์

ตารางที่ 2-1 ผังงานหลักที่ใช้งานไมโครคอนโทรลเลอร์ (ต่อ)

ตัวอย่างการเขียนลาดับขั้นขั้นตอนวิธี และการแปลงเป็ นผังงาน

เตรี ยมวัสดุ ไข่,หมูสับ,กระทะ... B

เอากระทะตั้งไฟ ใส่ ไข่ลงกระทะ

ขั้นที่ 3 แปลงผังงานเป็ นโปรแกรม

ตัวอยางโปรแกรมทีเ่ ขียนด้ วยโครงสร้ างแบบพน้ ฐาน

ตัวอยางโปรแกรมทีเ่ ขียนด้ วยโครงสร้ างแบบขั้นสู ง (ทีใ่ ห้ ผลแบบเดียวกับขั้นพน้ ฐาน)

หรื อ ชนิดของตัวแปร ชื่อตัวแปรที่1,ชื่อตัวแปรที่ 2,… ;

ตัวอยางอาร์ เรย์ 1 มิติ

ตัวอยางอาร์ เรย์ 2 มิติ x[0,0] x[0,1] x[0,2]

int x[3,3]; x[1,0] x[1,1] x[1,2]

/............../ ใช้ ในกรณีหลายบรรทัด