การทำงานและการประยุกต์ใช้จอ LCD ร่วมกับ Arduino Uno R3: สำหรับผู้เริ่มต้น

ในยุคที่เทคโนโลยีสมองกลฝังตัว (Embedded Systems) ได้เข้ามามีบทบาทสำคัญในทุกแง่มุมของชีวิตประจำวัน ตั้งแต่อุปกรณ์อัจฉริยะในบ้าน (Smart Home Devices) ไปจนถึงระบบควบคุมอัตโนมัติในอุตสาหกรรม การสื่อสารข้อมูลระหว่างระบบกับผู้ใช้งานกลายเป็นสิ่งจำเป็นอย่างยิ่ง หน้าจอแสดงผลจึงเปรียบเสมือนหน้าต่างที่เปิดโอกาสให้ผู้ใช้สามารถรับทราบสถานะการทำงาน ผลลัพธ์จากการประมวลผล หรือแม้กระทั่งการแจ้งเตือนต่างๆ ที่เกิดขึ้นภายในระบบได้อย่างรวดเร็วและเข้าใจง่าย หากปราศจากจอแสดงผล การโต้ตอบกับอุปกรณ์เหล่านี้จะกลายเป็นเรื่องยากลำบาก และลดทอนประโยชน์ใช้สอยของระบบลงอย่างมาก

ในบรรดาอุปกรณ์แสดงผลหลากหลายชนิดที่มีให้เลือกใช้ จอ Liquid Crystal Display (LCD) แบบตัวอักษร หรือ Character LCD ได้รับความนิยมอย่างแพร่หลายในหมู่นักพัฒนาไมโครคอนโทรลเลอร์และผู้เริ่มต้นใช้งาน Arduino ด้วยคุณสมบัติที่โดดเด่นในด้านความเรียบง่ายในการใช้งาน ความทนทาน และราคาที่เข้าถึงได้ จอ LCD จึงเป็นตัวเลือกที่ยอดเยี่ยมสำหรับการแสดงผลข้อความ ตัวเลข และสัญลักษณ์พื้นฐานได้อย่างมีประสิทธิภาพ โดยเฉพาะอย่างยิ่งจอ LCD ขนาด 16 ตัวอักษร 2 บรรทัด (16×2 Character LCD) ซึ่งเป็นรูปแบบที่พบเห็นได้บ่อยที่สุด จอประเภทนี้เหมาะอย่างยิ่งสำหรับโครงการที่ต้องการแสดงข้อมูลในรูปแบบข้อความสั้นๆ หรือค่าตัวเลขต่างๆ เช่น การแสดงอุณหภูมิ ความชื้น หรือสถานะการทำงานของอุปกรณ์

บทความฉบับนี้มีวัตถุประสงค์เพื่อนำเสนอความรู้เชิงลึกเกี่ยวกับการทำงานของจอ LCD แบบตัวอักษร โดยเริ่มต้นจากโครงสร้างพื้นฐานและหลักการทำงานของผลึกเหลว ไปจนถึงการทำความเข้าใจชิปควบคุมที่เป็นหัวใจสำคัญอย่าง Hitachi HD44780 นอกจากนี้ บทความจะอธิบายวิธีการเชื่อมต่อจอ LCD กับบอร์ดไมโครคอนโทรลเลอร์ Arduino Uno R3 ในสองรูปแบบหลัก ได้แก่ การเชื่อมต่อแบบขนาน (Parallel Interface) ซึ่งเป็นการเชื่อมต่อโดยตรง และการเชื่อมต่อผ่านโมดูล I2C (I2C Interface) ซึ่งช่วยลดจำนวนสายไฟที่ใช้ในการเชื่อมต่อลงได้อย่างมาก สำหรับแต่ละรูปแบบการเชื่อมต่อ จะมีการนำเสนอแผนภาพวงจรที่ชัดเจน โค้ดตัวอย่างการใช้งานอย่างละเอียดพร้อมคำอธิบายฟังก์ชันต่างๆ รวมถึงแนวทางการแก้ไขปัญหาที่พบบ่อย เพื่อให้นักเรียนและผู้สนใจทุกท่านสามารถนำความรู้และเทคนิคเหล่านี้ไปประยุกต์ใช้ในการพัฒนาโครงการสมองกลฝังตัวของตนเองได้อย่างมั่นใจและมีประสิทธิภาพ

ส่วนที่ 1: ทำความเข้าใจจอ LCD แบบตัวอักษร

โครงสร้างพื้นฐานและหลักการทำงานของ Liquid Crystal Display (LCD)

จอ LCD ทำงานบนหลักการที่น่าสนใจของผลึกเหลว ซึ่งเป็นสถานะของสสารที่มีคุณสมบัติกึ่งกลางระหว่างของเหลวและของแข็ง โมเลกุลของผลึกเหลวสามารถจัดเรียงตัวได้อย่างเป็นระเบียบคล้ายผลึก แต่ก็ยังสามารถไหลได้เหมือนของเหลว คุณสมบัติที่สำคัญที่สุดคือการที่โมเลกุลเหล่านี้สามารถเปลี่ยนทิศทางการจัดเรียงตัวได้เมื่อได้รับสนามไฟฟ้า การเปลี่ยนแปลงทิศทางนี้ส่งผลโดยตรงต่อการผ่านของแสงโพลาไรซ์ (Polarized Light) ที่ส่องผ่านตัวมัน ทำให้เราสามารถควบคุมปริมาณแสงที่ผ่านออกมาได้

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

สำหรับจอ LCD ขนาด 16×2 ซึ่งเป็นประเภทที่เราจะเน้นในบทความนี้ หมายถึงจอแสดงผลที่มีความสามารถในการแสดงตัวอักษรได้สูงสุด 16 ตัวอักษรในแต่ละบรรทัด และมีทั้งหมด 2 บรรทัด ทำให้สามารถแสดงผลตัวอักษรได้รวม 32 ตัวอักษรพร้อมกันในคราวเดียว แต่ละตัวอักษรบนจอ LCD 16×2 ไม่ได้ถูกสร้างขึ้นจากพิกเซลเดี่ยวๆ แต่เป็นเมทริกซ์ของจุดพิกเซลขนาด 5×8 จุด (5 คอลัมน์ x 8 แถว) การจัดเรียงพิกเซลเหล่านี้ตามรูปแบบที่กำหนดไว้ล่วงหน้าเป็นพื้นฐานในการสร้างรูปร่างของตัวอักษรมาตรฐานที่เราเห็นบนจอ

การที่แต่ละตัวอักษรถูกสร้างขึ้นจากเมทริกซ์ขนาด 5×8 พิกเซลนี้เองที่เป็นพื้นฐานสำคัญที่ทำให้ชิปควบคุม HD44780 สามารถรองรับความสามารถในการสร้าง “ตัวอักษรพิเศษ” (Custom Characters) ได้ในภายหลัง โดยปกติแล้ว จอ LCD จะมีชุดตัวอักษรมาตรฐานที่ฝังมาในหน่วยความจำภายใน (Character Generator ROM หรือ CGROM) แต่ด้วยโครงสร้างพิกเซล 5×8 จุดนี้ ผู้ใช้งานสามารถกำหนดรูปแบบการติด-ดับของพิกเซลทั้ง 40 จุด (5×8) ในแต่ละตัวอักษรพิเศษ เพื่อสร้างสัญลักษณ์ รูปร่าง หรือแม้แต่ไอคอนที่ไม่ใช่ตัวอักษรมาตรฐานได้ [5, 6, 7, 8] ความสามารถนี้ช่วยเพิ่มความยืดหยุ่นในการแสดงผลอย่างมหาศาล ทำให้จอ LCD สามารถสื่อสารข้อมูลที่ซับซ้อนหรือเฉพาะเจาะจงกับผู้ใช้ได้ดียิ่งขึ้น เช่น การแสดงสัญลักษณ์ลูกศร ไอคอนแบตเตอรี่ หรือกราฟิกง่ายๆ ซึ่งเป็นสิ่งที่ตัวอักษรมาตรฐานไม่สามารถทำได้ การทำความเข้าใจโครงสร้างพิกเซลนี้จึงเป็นก้าวแรกที่สำคัญในการปลดล็อกศักยภาพสูงสุดของจอ LCD ในโครงการต่างๆ

ชิปควบคุม Hitachi HD44780: หัวใจของการแสดงผล

หัวใจสำคัญที่อยู่เบื้องหลังการทำงานของจอ LCD แบบตัวอักษรส่วนใหญ่ในท้องตลาดคือชิปควบคุม Hitachi HD44780 ชิปนี้ได้รับการพัฒนาขึ้นในทศวรรษ 1980 โดยบริษัท Hitachi และได้กลายเป็นมาตรฐานอุตสาหกรรม (de facto standard) สำหรับจอ LCD ประเภทนี้ ด้วยเหตุนี้ จอ LCD แบบตัวอักษรเกือบทั้งหมดที่คุณพบเห็นในปัจจุบันจึงใช้ชิปควบคุมที่เข้ากันได้กับ HD44780 ไม่ว่าจะเป็นผู้ผลิตรายใดก็ตาม ทำให้การเขียนโปรแกรมควบคุมเป็นไปในทิศทางเดียวกันและสามารถใช้ไลบรารีมาตรฐาน เช่น LiquidCrystal Library ของ Arduino ได้อย่างแพร่หลาย

ชุดคำสั่งพื้นฐานของ HD44780

ชิป HD44780 มีชุดคำสั่งมาตรฐานที่ใช้ควบคุมการทำงานต่างๆ ของจอ LCD แม้ว่าไลบรารี Arduino จะช่วยให้เราไม่ต้องยุ่งเกี่ยวกับคำสั่งระดับบิตเหล่านี้โดยตรง แต่การทราบถึงฟังก์ชันหลักของคำสั่งเหล่านี้ก็มีประโยชน์ในการทำความเข้าใจการทำงานเบื้องหลัง:

• Clear display: คำสั่งนี้ใช้สำหรับล้างข้อมูลทั้งหมดบนหน้าจอ และย้ายเคอร์เซอร์กลับไปยังตำแหน่งเริ่มต้น (Address 0) เปรียบเสมือนการรีเซ็ตหน้าจอให้ว่างเปล่า
• Cursor home: คำสั่งนี้จะย้ายเคอร์เซอร์กลับไปยังตำแหน่งเริ่มต้น (Address 0) โดยไม่ล้างข้อมูลบนหน้าจอ หากมีการเลื่อนจอแสดงผล (Display Shift) คำสั่งนี้จะทำให้จอกลับสู่ตำแหน่งเดิมด้วย
• Entry mode set: คำสั่งนี้ใช้กำหนดทิศทางการเลื่อนเคอร์เซอร์หลังจากมีการเขียนข้อมูล (เพิ่มขึ้นหรือลดลง) และกำหนดว่าจะให้จอแสดงผลเลื่อนอัตโนมัติหรือไม่เมื่อมีการเขียนข้อมูล
• Display on/off control: คำสั่งนี้ควบคุมการเปิดหรือปิดจอแสดงผลทั้งหมด การเปิดหรือปิดเคอร์เซอร์ และการเปิดหรือปิดการกระพริบของเคอร์เซอร์
• Function set: คำสั่งนี้เป็นคำสั่งสำคัญที่ใช้กำหนดโหมดการเชื่อมต่อข้อมูล (4-bit หรือ 8-bit), จำนวนบรรทัดที่แสดงผล (1 บรรทัด หรือ 2 บรรทัด), และขนาดฟอนต์ของตัวอักษร (5×8 หรือ 5×10 พิกเซล) ซึ่งต้องตั้งค่าให้ถูกต้องตามลักษณะของจอ LCD ที่ใช้งาน
• Set CGRAM address: ใช้กำหนด Address สำหรับการเข้าถึงหน่วยความจำ CGRAM เมื่อต้องการเขียนหรืออ่านข้อมูลรูปแบบพิกเซลของตัวอักษรพิเศษ
• Set DDRAM address: ใช้กำหนด Address สำหรับการเข้าถึงหน่วยความจำ DDRAM เมื่อต้องการเขียนหรืออ่านข้อมูลตัวอักษรที่จะแสดงบนหน้าจอ

การมีอยู่ของไลบรารี Arduino เช่น LiquidCrystal.h และ LiquidCrystal_I2C.h เป็นปัจจัยสำคัญที่ช่วยให้นักพัฒนาสามารถควบคุมจอ LCD ได้โดยไม่ต้องกังวลกับการส่งคำสั่งระดับบิตที่ซับซ้อนเหล่านี้โดยตรง ไลบรารีเหล่านี้ทำหน้าที่เป็นชั้นนามธรรม (Abstraction Layer) ที่แปลงคำสั่งที่เข้าใจง่าย เช่น lcd.print("Hello"); ไปเป็นชุดคำสั่ง HD44780 ที่เหมาะสม ซึ่งช่วยลดความซับซ้อนในการพัฒนาโปรเจกต์ได้อย่างมหาศาล ทำให้ผู้เริ่มต้นสามารถใช้งานจอ LCD ได้อย่างรวดเร็วและมีประสิทธิภาพ

การทำงานของขาต่างๆ บนจอ LCD (Pinout Configuration)

จอ LCD 16×2 โดยทั่วไปมีขาเชื่อมต่อทั้งหมด 16 ขา (บางรุ่นที่ไม่มีไฟ Backlight อาจมีเพียง 14 ขา) แต่ละขามีหน้าที่เฉพาะเจาะจงในการควบคุมการทำงานของจอ การทำความเข้าใจหน้าที่ของแต่ละขาเป็นสิ่งสำคัญอย่างยิ่งสำหรับการเชื่อมต่อวงจรที่ถูกต้อง โดยเฉพาะอย่างยิ่งในการเชื่อมต่อแบบขนาน

ส่วนที่ 2: การเชื่อมต่อจอ LCD แบบขนาน (Parallel Interface) กับ Arduino Uno R3

การเชื่อมต่อจอ LCD แบบขนานเป็นวิธีการเชื่อมต่อโดยตรงกับไมโครคอนโทรลเลอร์ โดยต้องใช้ขา Digital I/O จำนวนมากในการควบคุม การทำความเข้าใจหลักการและวิธีการเชื่อมต่อแบบนี้เป็นพื้นฐานสำคัญก่อนที่จะก้าวไปสู่การเชื่อมต่อแบบ I2C

2.1 หลักการและข้อดีข้อจำกัด

หลักการทำงาน

การเชื่อมต่อจอ LCD แบบขนานหมายถึงการส่งข้อมูลหลายบิตพร้อมกันผ่านขาข้อมูลหลายๆ ขาของไมโครคอนโทรลเลอร์ ชิปควบคุม HD44780 รองรับการทำงานสองโหมดหลักสำหรับการรับส่งข้อมูล:

• 8-bit mode: ในโหมดนี้ จะใช้ขาข้อมูล DB0-DB7 ทั้งหมด 8 ขาในการส่งข้อมูล 8 บิตพร้อมกันในครั้งเดียว ซึ่งเป็นวิธีที่เร็วที่สุดในการสื่อสารข้อมูล
• 4-bit mode: ในโหมดนี้ จะใช้ขาข้อมูลเพียง 4 ขา คือ DB4-DB7 ข้อมูล 8 บิตจะถูกส่งเป็นสองส่วน (nibbles) โดยส่ง 4 บิตบน (Most Significant Nibble) ก่อน แล้วตามด้วย 4 บิตล่าง (Least Significant Nibble) การส่งข้อมูลแต่ละครั้งจะมีการกระตุ้นขา Enable (E) เพื่อให้ชิป HD44780 รับข้อมูล

นอกจากขาข้อมูลแล้ว การเชื่อมต่อแบบขนานยังต้องใช้ขาควบคุมอีก 3 ขา ได้แก่:

• RS (Register Select): ใช้เลือกโหมดการทำงานระหว่างโหมดคำสั่ง (RS=0) สำหรับส่งคำสั่งควบคุมจอ และโหมดข้อมูล (RS=1) สำหรับส่งตัวอักษรที่จะแสดง
• R/W (Read/Write): ใช้เลือกโหมดการทำงานระหว่างการเขียนข้อมูลไปยังจอ (R/W=0) และการอ่านข้อมูลจากจอ (R/W=1) ในการใช้งานทั่วไปมักจะต่อขา R/W ลงกราวด์ถาวร (R/W=0) เนื่องจากส่วนใหญ่เราจะเขียนข้อมูลไปยังจอเท่านั้น ไม่ค่อยมีการอ่านข้อมูลกลับ
• E (Enable): ใช้เป็นสัญญาณนาฬิกา (Clock Signal) เพื่อบอกให้ชิป HD44780 รับข้อมูลหรือคำสั่งที่ส่งมา การส่งข้อมูลหรือคำสั่งแต่ละครั้งจะมีการกระตุ้นขา E โดยการเปลี่ยนสถานะจาก High ไป Low (Falling Edge)

ในการเชื่อมต่อกับบอร์ด Arduino Uno R3 นิยมใช้โหมด 4-bit มากกว่า แม้ว่าการส่งข้อมูลจะใช้เวลามากกว่าเล็กน้อยเนื่องจากต้องส่งเป็นสองส่วน แต่ก็ช่วยประหยัดขา Digital I/O ของ Arduino ได้อย่างมาก โดยรวมแล้วโหมด 4-bit จะใช้ขา Digital I/O เพียง 7 ขา (RS, E, D4-D7) ในขณะที่โหมด 8-bit ต้องใช้ถึง 11 ขา [3, 9] ซึ่ง Arduino Uno R3 มีขา Digital I/O เพียง 14 ขา การประหยัดขาจึงเป็นสิ่งสำคัญสำหรับโครงการที่มีอุปกรณ์ต่อพ่วงอื่นๆ

ข้อดีของการเชื่อมต่อแบบขนาน

• การควบคุมโดยตรง: ผู้ใช้งานสามารถควบคุมการทำงานของจอ LCD ได้อย่างละเอียดในระดับฮาร์ดแวร์ หากต้องการ
• ความเร็วในการส่งข้อมูล: ในทางทฤษฎี โหมด 8-bit สามารถส่งข้อมูลได้เร็วกว่าการสื่อสารแบบอนุกรม (Serial Communication) อย่าง I2C เนื่องจากสามารถส่งข้อมูลได้พร้อมกัน 8 บิตในครั้งเดียว อย่างไรก็ตาม สำหรับการแสดงผลตัวอักษรทั่วไป ความเร็วในการส่งข้อมูลมักจะไม่ใช่ข้อจำกัดที่สำคัญ

ข้อจำกัดของการเชื่อมต่อแบบขนาน

• ใช้ขา Digital I/O จำนวนมาก: นี่คือข้อจำกัดที่ใหญ่ที่สุด การเชื่อมต่อแบบ 4-bit ใช้ 7 ขา และแบบ 8-bit ใช้ถึง 11 ขา ซึ่งอาจทำให้ขา I/O ของ Arduino ไม่เพียงพอสำหรับอุปกรณ์อื่นๆ ในโครงการที่ซับซ้อน
• การเดินสายที่ซับซ้อน: ด้วยจำนวนสายที่มาก การเชื่อมต่อแบบขนานจึงมีโอกาสเกิดข้อผิดพลาดในการเดินสายได้ง่ายกว่า และอาจทำให้วงจรดูไม่เป็นระเบียบ
• ความอ่อนไหวต่อสัญญาณรบกวน: สายไฟจำนวนมากที่ยาวอาจทำให้เกิดปัญหาสัญญาณรบกวน (Noise) ได้ง่ายขึ้น ซึ่งอาจส่งผลต่อความเสถียรในการสื่อสารข้อมูล

2.2 อุปกรณ์ที่จำเป็น

สำหรับการเชื่อมต่อจอ LCD 16×2 แบบขนานกับ Arduino Uno R3 คุณจะต้องเตรียมอุปกรณ์ดังต่อไปนี้:

• บอร์ด Arduino Uno R3: 1 บอร์ด
• จอ LCD 16×2 Character LCD: 1 จอ (ควรเป็นรุ่นที่ใช้ชิปควบคุม HD44780 หรือเข้ากันได้)
• ตัวต้านทานปรับค่าได้ (Potentiometer) ขนาด 10K โอห์ม: 1 ตัว (สำหรับปรับความคมชัดของจอ)
• ตัวต้านทาน (Resistor) ขนาด 220 โอห์ม: 1 ตัว (สำหรับจำกัดกระแสไฟ Backlight เพื่อป้องกัน LED เสียหาย)
• สายไฟจัมเปอร์ (Jumper Wires): ชนิดผู้-ผู้ (Male-to-Male) จำนวนมากพอสำหรับเชื่อมต่อขาต่างๆ
• โปรโตบอร์ด (Breadboard): 1 แผง (สำหรับจัดวงจรและทดลอง)

โค้ดตัวอย่างการใช้งาน (LiquidCrystal Library)

การควบคุมจอ LCD ด้วย Arduino Uno R3 ในโหมดขนานจะใช้ไลบรารีมาตรฐานที่ชื่อว่า LiquidCrystal.h ซึ่งมาพร้อมกับ Arduino IDE อยู่แล้ว จึงไม่จำเป็นต้องดาวน์โหลดเพิ่มเติม ไลบรารีนี้ช่วยให้การเขียนโปรแกรมควบคุมจอ LCD ที่ใช้ชิป HD44780 เป็นเรื่องง่ายขึ้นอย่างมาก โดยแปลงคำสั่งระดับสูงที่เราเข้าใจไปเป็นชุดคำสั่งระดับบิตที่ชิป HD44780 ต้องการ

ภาพรวมไลบรารี LiquidCrystal

ไลบรารี LiquidCrystal เป็นเครื่องมือสำคัญที่ช่วยให้นักพัฒนาสามารถสื่อสารกับจอ LCD ที่เข้ากันได้กับไดรเวอร์ Hitachi HD44780 ได้อย่างมีประสิทธิภาพ ไลบรารีนี้ถูกออกแบบมาเพื่อรองรับการทำงานทั้งในโหมด 4-bit และ 8-bit และมีฟังก์ชันที่หลากหลายสำหรับการควบคุมการแสดงผล เช่น การเลื่อนข้อความ การกระพริบหน้าจอ การควบคุมเคอร์เซอร์ และการสร้างตัวอักษรพิเศษ

การจะใช้งานไลบรารี LiquidCrystal ใน Arduino Sketch จำเป็นต้องมีองค์ประกอบหลักสามส่วน:

1. การเรียกใช้งานไลบรารี: ต้องเพิ่มบรรทัด #include <LiquidCrystal.h> ที่ส่วนบนสุดของโค้ด เพื่อบอกให้คอมไพเลอร์ทราบว่าจะต้องใช้ฟังก์ชันที่ประกาศไว้ในไลบรารีนี้
2. การประกาศและกำหนดค่าอ็อบเจกต์ LiquidCrystal: ต้องสร้างอ็อบเจกต์ของคลาส LiquidCrystal โดยระบุขา Arduino ที่เชื่อมต่อกับขาควบคุมและขาข้อมูลของ LCD ตัวอย่างเช่น LiquidCrystal lcd(12, 11, 5, 4, 3, 2); โดยตัวเลขในวงเล็บคือหมายเลขขา Arduino ที่เชื่อมต่อกับ RS, E, D4, D5, D6, D7 ตามลำดับ ชื่อ lcd สามารถเปลี่ยนเป็นชื่ออื่นได้ตามต้องการ
3. การเริ่มต้นการทำงานของจอ LCD: ภายในฟังก์ชัน setup() ต้องเรียกใช้ฟังก์ชัน lcd.begin(cols, rows); เพื่อกำหนดขนาดของจอ LCD ในหน่วยคอลัมน์และแถว เช่น lcd.begin(16, 2); สำหรับจอ 16×2 ไลบรารีนี้รองรับจอ LCD ได้หลายขนาด เพียงแค่เปลี่ยนตัวเลขในฟังก์ชัน begin() ให้ตรงกับขนาดของจอที่ใช้

ฟังก์ชันสำคัญในไลบรารี LiquidCrystal

ไลบรารี LiquidCrystal มีฟังก์ชันมากมายที่ช่วยให้การควบคุมจอ LCD เป็นไปอย่างง่ายดาย:

• lcd.begin(cols, rows);: ใช้เริ่มต้นการทำงานของจอ LCD และกำหนดขนาดของจอในหน่วยคอลัมน์ (ตัวอักษรแนวนอน) และแถว (บรรทัดแนวตั้ง) เช่น lcd.begin(16, 2); สำหรับจอ 16×2
• lcd.setCursor(col, row);: ใช้กำหนดตำแหน่งของเคอร์เซอร์ ซึ่งเป็นตำแหน่งที่ตัวอักษรหรือข้อมูลถัดไปจะถูกพิมพ์ลงบนจอ โดย col คือคอลัมน์ (เริ่มต้นจาก 0) และ row คือแถว (เริ่มต้นจาก 0) เช่น lcd.setCursor(0, 0); คือตำแหน่งแรกของบรรทัดแรก
• lcd.print(data);: ใช้สำหรับพิมพ์ข้อความ ตัวเลข หรือค่าจากตัวแปรลงบนจอ LCD ที่ตำแหน่งเคอร์เซอร์ปัจจุบัน หากเป็นข้อความต้องอยู่ในเครื่องหมายคำพูด (” “) แต่ถ้าเป็นตัวแปร ไม่ต้องมีเครื่องหมายคำพูด
• lcd.clear();: ใช้สำหรับล้างข้อมูลทั้งหมดบนหน้าจอ และย้ายเคอร์เซอร์กลับไปยังตำแหน่งเริ่มต้น (0,0)
• lcd.home();: ย้ายเคอร์เซอร์กลับไปยังตำแหน่งเริ่มต้น (0,0) โดยไม่ล้างข้อมูลบนหน้าจอ [18]
• lcd.display(); / lcd.noDisplay();: ใช้สำหรับเปิดหรือปิดการแสดงผลของจอ LCD เมื่อปิดจอ ข้อมูลที่เคยแสดงจะยังคงอยู่ในหน่วยความจำ และจะกลับมาแสดงอีกครั้งเมื่อเปิดจอ
• lcd.cursor(); / lcd.noCursor();: ใช้สำหรับเปิดหรือปิดการแสดงเคอร์เซอร์แบบขีดเส้นใต้ (underscore)
• lcd.blink(); / lcd.noBlink();: ใช้สำหรับเปิดหรือปิดการกระพริบของเคอร์เซอร์
• lcd.scrollDisplayLeft(); / lcd.scrollDisplayRight();: ใช้สำหรับเลื่อนข้อความทั้งหมดบนจอไปทางซ้ายหรือขวาตามลำดับ
• lcd.autoscroll(); / lcd.noAutoscroll();: ใช้สำหรับเปิดหรือปิดโหมดเลื่อนข้อความอัตโนมัติ เมื่อเปิดโหมดนี้ ข้อความใหม่ที่พิมพ์จะทำให้ข้อความเดิมเลื่อนไปทางซ้ายหนึ่งช่อง
• lcd.leftToRight(); / lcd.rightToLeft();: กำหนดทิศทางการพิมพ์ข้อความจากซ้ายไปขวา หรือขวาไปซ้าย
• lcd.createChar(char_num, data);: ฟังก์ชันนี้เป็นกุญแจสำคัญในการสร้างตัวอักษรพิเศษ โดย char_num คือหมายเลขช่องเก็บตัวอักษรพิเศษ (0-7) และ data คืออาร์เรย์ของไบต์ 8 ตัวที่กำหนดรูปแบบพิกเซลของตัวอักษรนั้นๆ
• lcd.write(char_num);: ใช้สำหรับแสดงตัวอักษรพิเศษที่สร้างขึ้นด้วย createChar() โดย char_num คือหมายเลขช่องเก็บตัวอักษรพิเศษ (0-7)

ตัวอย่างโค้ด “Hello World!” (การเชื่อมต่อแบบขนาน)

โค้ดตัวอย่างนี้จะแสดงข้อความ “Hello World!” บนบรรทัดแรก และแสดงเวลาที่ Arduino ทำงานเป็นวินาทีบนบรรทัดที่สอง

#include <LiquidCrystal.h> // เรียกใช้งานไลบรารี LiquidCrystal

// กำหนดขา Arduino ที่เชื่อมต่อกับขา LCD:
// LiquidCrystal lcd(RS, Enable, D4, D5, D6, D7);
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  // กำหนดขนาดของจอ LCD เป็น 16 ตัวอักษร 2 บรรทัด
  lcd.begin(16, 2);
  // พิมพ์ข้อความ "Hello World!" บนบรรทัดแรก (ตำแหน่งเริ่มต้น 0,0)
  lcd.print("Hello World!");
}

void loop() {
  // กำหนดตำแหน่งเคอร์เซอร์ไปที่คอลัมน์ 0, แถวที่ 1 (บรรทัดที่สอง)
  lcd.setCursor(0, 1);
  // พิมพ์เวลาที่ Arduino ทำงานเป็นวินาที (millis() คือจำนวนมิลลิวินาทีตั้งแต่รีเซ็ต)
  lcd.print(millis() / 1000);
}

ตัวอย่างโค้ด “การสร้างตัวอักษรพิเศษ” (การเชื่อมต่อแบบขนาน)

โค้ดนี้จะสาธิตวิธีการสร้างและแสดงตัวอักษรพิเศษบนจอ LCD โดยเราจะสร้างตัวอักษรที่คล้ายรูปหัวใจ

#include <LiquidCrystal.h> // เรียกใช้งานไลบรารี LiquidCrystal

// กำหนดขา Arduino ที่เชื่อมต่อกับขา LCD:
// LiquidCrystal lcd(RS, Enable, D4, D5, D6, D7);
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// กำหนดรูปแบบพิกเซลของตัวอักษรพิเศษ (รูปหัวใจ)
// แต่ละไบต์แทนแต่ละแถวของตัวอักษร 5x8 พิกเซล
// 0b00000 หมายถึง ปิดพิกเซลทั้งหมดในแถวนั้น
// 0b11111 หมายถึง เปิดพิกเซลทั้งหมดในแถวนั้น
byte heartChar = {
  0b00000,
  0b01010,
  0b11111,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000
};

void setup() {
  // กำหนดขนาดของจอ LCD
  lcd.begin(16, 2);

  // สร้างตัวอักษรพิเศษหมายเลข 0 ด้วยรูปแบบ heartChar
  lcd.createChar(0, heartChar);

  // กำหนดตำแหน่งเคอร์เซอร์ไปที่คอลัมน์ 0, แถว 0
  lcd.setCursor(0, 0);
  // พิมพ์ตัวอักษรพิเศษหมายเลข 0
  lcd.write((uint8_t)0); // (uint8_t)0 คือรหัสของตัวอักษรพิเศษหมายเลข 0

  lcd.print(" I Love Arduino!"); // พิมพ์ข้อความปกติ
}

void loop() {
  // ไม่มีการทำงานเพิ่มเติมใน loop สำหรับตัวอย่างนี้
}

การสร้างตัวอักษรพิเศษช่วยเพิ่มความสามารถในการแสดงผลของจอ LCD ได้อย่างมาก ทำให้สามารถแสดงสัญลักษณ์หรือกราฟิกง่ายๆ ที่ช่วยให้ข้อมูลมีความหมายและน่าสนใจยิ่งขึ้นสำหรับผู้ใช้งาน

ส่วนที่ 3: การเชื่อมต่อจอ LCD แบบ I2C กับ Arduino Uno R3

แม้ว่าการเชื่อมต่อแบบขนานจะตรงไปตรงมา แต่ข้อจำกัดเรื่องจำนวนขา Digital I/O ที่ใช้ไปเป็นจำนวนมาก ทำให้เกิดความไม่สะดวกในโครงการที่มีอุปกรณ์อื่นๆ ที่ต้องใช้ขา I/O เช่นกัน เพื่อแก้ไขปัญหานี้ โมดูล I2C Adapter สำหรับจอ LCD จึงถูกพัฒนาขึ้นมา ซึ่งช่วยลดจำนวนสายไฟที่ใช้ในการเชื่อมต่อได้อย่างมาก

3.1 หลักการและข้อดีข้อจำกัดของ I2C Interface

หลักการทำงานของ I2C Interface

I2C (Inter-Integrated Circuit) เป็นโปรโตคอลการสื่อสารแบบอนุกรม (Serial Communication Protocol) ที่พัฒนาโดย Philips Semiconductor (ปัจจุบันคือ NXP Semiconductors) โปรโตคอลนี้ช่วยให้อุปกรณ์หลายตัวสามารถสื่อสารกันได้โดยใช้สายไฟเพียงสองเส้นหลักเท่านั้น ได้แก่:

• SDA (Serial Data Line): สายสำหรับส่งและรับข้อมูล
• SCL (Serial Clock Line): สายสำหรับส่งสัญญาณนาฬิกา เพื่อซิงโครไนซ์การรับส่งข้อมูลระหว่างอุปกรณ์

สำหรับจอ LCD ที่ใช้ I2C นั้น โดยทั่วไปแล้วตัวจอ LCD เองยังคงเป็นอุปกรณ์ที่รับข้อมูลแบบขนาน (Parallel Device) และใช้ชิปควบคุม HD44780 เช่นเดิม แต่จะมีการเพิ่ม โมดูล I2C Adapter เข้ามาต่อด้านหลังจอ LCD โมดูลนี้มักจะใช้ชิปขยายพอร์ต I/O เช่น PCF8574 หรือ PCF8574A ซึ่งทำหน้าที่เป็นตัวกลางในการแปลงสัญญาณ I2C แบบอนุกรมที่มาจาก Arduino ให้เป็นสัญญาณแบบขนานที่จอ LCD เข้าใจ และในทางกลับกันก็แปลงสัญญาณจากจอ LCD กลับเป็น I2C เพื่อส่งไปยัง Arduino

ข้อดีของการเชื่อมต่อแบบ I2C

• ลดจำนวนขา Digital I/O อย่างมาก: นี่คือข้อได้เปรียบที่สำคัญที่สุด การเชื่อมต่อแบบ I2C ใช้สายไฟข้อมูลเพียง 2 เส้น (SDA, SCL) บวกกับสายไฟเลี้ยง (VCC, GND) อีก 2 เส้น รวมเป็นเพียง 4 เส้นเท่านั้น เปรียบเทียบกับการเชื่อมต่อแบบขนานที่ต้องใช้ 7-11 ขา ทำให้ประหยัดขา I/O ของ Arduino ได้อย่างมหาศาล ซึ่งเป็นประโยชน์อย่างยิ่งสำหรับโครงการที่มีอุปกรณ์ต่อพ่วงหลายชิ้นหรือใช้บอร์ด Arduino รุ่นที่มีขา I/O จำกัด
• ลดความซับซ้อนในการเดินสาย: ด้วยจำนวนสายที่น้อยลง การเดินสายวงจรจึงง่ายขึ้นมาก ลดโอกาสเกิดข้อผิดพลาดในการเชื่อมต่อ และทำให้วงจรดูเป็นระเบียบเรียบร้อย
• ลดสัญญาณรบกวน: จำนวนสายที่น้อยลงช่วยลดปัญหาการเกิดสัญญาณรบกวนในสายไฟได้ดีกว่าการเชื่อมต่อแบบขนาน [13]
• รองรับอุปกรณ์หลายตัวบนบัสเดียวกัน: โปรโตคอล I2C เป็นแบบ Master-Slave ที่อนุญาตให้อุปกรณ์หลายตัว (Slave) สามารถเชื่อมต่ออยู่บนบัส I2C เดียวกันกับไมโครคอนโทรลเลอร์ (Master) ได้ โดยแต่ละอุปกรณ์จะมี Address เฉพาะตัว ทำให้สามารถต่อจอ LCD หลายตัว หรือเซ็นเซอร์ I2C อื่นๆ ร่วมกันได้โดยใช้สายไฟเพียง 2 เส้นคู่เดิม

สำหรับจอ LCD แบบตัวอักษร ความเร็วในการส่งข้อมูลมักจะไม่ใช่ข้อจำกัดที่สำคัญ ดังนั้นการลดจำนวนขาที่ใช้และการทำให้การเดินสายง่ายขึ้นจึงเป็นประโยชน์อย่างมากสำหรับนักพัฒนา โดยเฉพาะอย่างยิ่งสำหรับผู้เริ่มต้นและโครงการที่เน้นความเรียบง่ายและประหยัดทรัพยากรขา I/O

ข้อจำกัดของการเชื่อมต่อแบบ I2C

• อัตราการถ่ายโอนข้อมูลช้ากว่า: เมื่อเทียบกับโปรโตคอลแบบขนานหรือ SPI (Serial Peripheral Interface) อัตราการถ่ายโอนข้อมูลของ I2C จะช้ากว่า อย่างไรก็ตาม สำหรับการแสดงผลข้อความบนจอ LCD แบบตัวอักษร ความเร็วนี้มักจะเพียงพอและไม่เป็นปัญหา
• ขนาดของ Data Frame จำกัด: ขนาดของ Data Frame ที่ส่งต่อกันใน I2C ถูกจำกัดอยู่ที่ 8 บิต
• ความซับซ้อนของฮาร์ดแวร์ (ภายในโมดูล): แม้ว่าการเชื่อมต่อภายนอกจะง่าย แต่โมดูล I2C Adapter เองก็มีฮาร์ดแวร์ที่ซับซ้อนกว่าการเชื่อมต่อแบบขนานเล็กน้อย เนื่องจากต้องมีชิปขยายพอร์ต I/O และวงจรที่เกี่ยวข้อง

3.2 อุปกรณ์ที่จำเป็น

สำหรับการเชื่อมต่อจอ LCD 16×2 แบบ I2C กับ Arduino Uno R3 คุณจะต้องเตรียมอุปกรณ์ดังต่อไปนี้:

• บอร์ด Arduino Uno R3: 1 บอร์ด
• จอ LCD 16×2 Character LCD พร้อมโมดูล I2C Adapter (I2C LCD Display): 1 จอ (โมดูล I2C มักจะถูกบัดกรีติดมากับจอแล้ว)
• สายไฟจัมเปอร์ (Jumper Wires): ชนิดผู้-เมีย (Male-to-Female) หรือผู้-ผู้ (Male-to-Male) จำนวน 4 เส้น

3.3 แผนภาพวงจรและการเชื่อมต่อ

การเชื่อมต่อจอ LCD 16×2 แบบ I2C กับ Arduino Uno R3 ทำได้ง่ายมาก โดยใช้สายไฟเพียง 4 เส้นเท่านั้น:

1. GND (กราวด์):
   • ขา GND ของ I2C LCD Module: เชื่อมต่อกับขา GND ของ Arduino Uno R3
2. VCC (ไฟเลี้ยง):
   • ขา VCC ของ I2C LCD Module: เชื่อมต่อกับขา 5V ของ Arduino Uno R3
3. SDA (Serial Data Line):
   • ขา SDA ของ I2C LCD Module: เชื่อมต่อกับขา Analog A4 ของ Arduino Uno R3
4. SCL (Serial Clock Line):
   • ขา SCL ของ I2C LCD Module: เชื่อมต่อกับขา Analog A5 ของ Arduino Uno R3

แผนภาพวงจร (Conceptual Diagram):

Arduino Uno R3             I2C LCD Module
-------------             ----------------
      GND -----+------------ GND
       5V -----+------------ VCC
       A4 -----+------------ SDA
       A5 -----+------------ SCL

หลังจากเชื่อมต่อวงจรเสร็จสิ้น สิ่งสำคัญอีกประการหนึ่งคือการปรับความคมชัดของจอ LCD โมดูล I2C LCD ส่วนใหญ่จะมีตัวต้านทานปรับค่าได้ (Potentiometer) ขนาดเล็กอยู่ด้านหลัง ซึ่งสามารถหมุนปรับได้ด้วยไขควงขนาดเล็ก เมื่อจ่ายไฟให้กับ Arduino และจอ LCD ควรจะเห็นไฟ Backlight สว่างขึ้น จากนั้นให้ค่อยๆ หมุน Potentiometer นี้จนกระทั่งเห็นแถบสี่เหลี่ยมเล็กๆ ปรากฏขึ้นบนหน้าจอ (สำหรับจอ 16×2 อาจเห็นเป็นหนึ่งหรือสองแถวของสี่เหลี่ยม) การปรับความคมชัดที่เหมาะสมเป็นขั้นตอนเริ่มต้นที่สำคัญมาก หากไม่ปรับ จออาจแสดงผลเป็นแถบสีดำทั้งหมด หรือตัวอักษรจางจนมองไม่เห็น ซึ่งเป็นปัญหาที่พบบ่อยสำหรับผู้เริ่มต้น

3.4 การค้นหา I2C Address ของจอ LCD

ก่อนที่จะเขียนโค้ดเพื่อแสดงผลบนจอ I2C LCD สิ่งสำคัญคือต้องทราบ I2C Address ที่ถูกต้องของโมดูลนั้นๆ แม้ว่าโมดูล I2C LCD ส่วนใหญ่จะมาพร้อมกับ Address เริ่มต้นที่ 0x27 แต่บางรุ่นหรือจากผู้ผลิตที่แตกต่างกันอาจใช้ Address อื่น เช่น 0x3F หากระบุ Address ไม่ถูกต้อง จอ LCD จะไม่สามารถสื่อสารกับ Arduino ได้ และจะไม่แสดงผลใดๆ

โค้ด I2C Scanner

Arduino IDE มีโค้ดตัวอย่างสำหรับสแกนหา I2C Address ของอุปกรณ์ต่างๆ บนบัส I2C ซึ่งสามารถนำมาใช้กับจอ LCD ได้

#include <Wire.h> // เรียกใช้งานไลบรารี Wire สำหรับการสื่อสาร I2C

void setup() {
  Wire.begin(); // เริ่มต้นการสื่อสาร I2C
  Serial.begin(9600); // เริ่มต้น Serial Monitor ที่ Baud Rate 9600
  while (!Serial); // รอให้ Serial Monitor พร้อมใช้งาน (สำหรับบอร์ดบางรุ่น เช่น Leonardo)
  Serial.println("\nI2C Scanner"); // พิมพ์ข้อความเริ่มต้น
}

void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Scanning..."); // พิมพ์ข้อความแจ้งว่ากำลังสแกน
  nDevices = 0; // รีเซ็ตจำนวนอุปกรณ์ที่พบ

  // วนลูปสแกนหา Address ตั้งแต่ 1 ถึง 126 (Address 0 และ 127 เป็น Address สงวน)
  for (address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address); // เริ่มต้นการส่งข้อมูลไปยัง Address ปัจจุบัน
    error = Wire.endTransmission(); // สิ้นสุดการส่งข้อมูลและตรวจสอบสถานะ

    if (error == 0) { // ถ้า error เป็น 0 แสดงว่าพบอุปกรณ์ที่ Address นี้
      Serial.print("I2C device found at address 0x");
      if (address < 16)
        Serial.print("0"); // เพิ่ม 0 ข้างหน้าหาก Address เป็นเลขหลักเดียว (เพื่อให้อยู่ในรูปแบบ Hex 2 หลัก)
      Serial.print(address, HEX); // พิมพ์ Address ในรูปแบบ Hexadecimal
      Serial.println("!");
      nDevices++; // เพิ่มจำนวนอุปกรณ์ที่พบ
    } else if (error == 4) { // ถ้า error เป็น 4 แสดงว่าเกิดข้อผิดพลาดที่ไม่รู้จัก
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }

  if (nDevices == 0) { // ถ้าไม่พบอุปกรณ์ใดๆ
    Serial.println("No I2C devices found\n");
  } else { // ถ้าพบอุปกรณ์
    Serial.println("done\n");
  }

  delay(5000); // รอ 5 วินาทีก่อนที่จะสแกนอีกครั้ง
}

วิธีการใช้งาน I2C Scanner Code

1. เชื่อมต่อวงจร: ตรวจสอบให้แน่ใจว่าได้เชื่อมต่อ I2C LCD Module กับ Arduino Uno R3 อย่างถูกต้องตามแผนภาพวงจรในหัวข้อ 3.3
2. อัปโหลดโค้ด: คัดลอกโค้ด I2C Scanner ด้านบนลงใน Arduino IDE แล้วอัปโหลดไปยังบอร์ด Arduino Uno R3 ของคุณ
3. เปิด Serial Monitor: หลังจากอัปโหลดโค้ดเสร็จสิ้น ให้เปิด Serial Monitor โดยไปที่เมนู Tools > Serial Monitor หรือกด Ctrl + Shift + M
4. ดูผลลัพธ์: Serial Monitor จะแสดงผลการสแกน หากพบอุปกรณ์ I2C จะแสดงข้อความระบุ Address ในรูปแบบ Hexadecimal เช่น “I2C device found at address 0x27!”
5. จดบันทึก Address: จดบันทึก I2C Address ที่พบไว้ เนื่องจากจะต้องใช้ Address นี้ในการกำหนดค่าในโค้ดสำหรับควบคุมจอ LCD ในขั้นตอนถัดไป

3.5 โค้ดตัวอย่างการใช้งาน (LiquidCrystal_I2C Library)

สำหรับการควบคุมจอ LCD ผ่านโมดูล I2C เราจะต้องใช้ไลบรารีที่แตกต่างจาก LiquidCrystal.h นั่นคือ LiquidCrystal_I2C.h ซึ่งไม่ได้มาพร้อมกับ Arduino IDE โดยตรง ดังนั้นจึงต้องทำการติดตั้งเพิ่มเติม

ภาพรวมไลบรารี LiquidCrystal_I2C

ไลบรารี LiquidCrystal_I2C ถูกออกแบบมาโดยเฉพาะเพื่อทำงานร่วมกับโมดูล I2C Adapter ที่ใช้ชิปขยายพอร์ต I/O เช่น PCF8574 ไลบรารีนี้มีฟังก์ชันการทำงานที่คล้ายคลึงกับไลบรารี LiquidCrystal มาตรฐาน ทำให้ผู้ที่คุ้นเคยกับการควบคุมจอ LCD แบบขนานสามารถปรับตัวมาใช้งานแบบ I2C ได้อย่างรวดเร็ว ไลบรารี LiquidCrystal_I2C ยังทำงานร่วมกับไลบรารี Wire.h ซึ่งเป็นไลบรารีมาตรฐานของ Arduino สำหรับการสื่อสาร I2C (ในเวอร์ชันใหม่ๆ ของ LiquidCrystal_I2C อาจมีการรวม Wire.h เข้าไปโดยอัตโนมัติแล้ว)

การติดตั้งไลบรารี LiquidCrystal_I2C

1. เปิด Arduino IDE: เปิดโปรแกรม Arduino IDE ขึ้นมา
2. เข้าสู่ Library Manager: ไปที่เมนู Sketch > Include Library > Manage Libraries... (หรือกด Ctrl + Shift + I บน Windows)
3. ค้นหาไลบรารี: ในช่องค้นหา ให้พิมพ์คำว่า “LiquidCrystal_I2C”
4. เลือกและติดตั้ง: มองหาไลบรารีชื่อ “LiquidCrystal_I2C” ที่เขียนโดย Frank de Brabander (หรือผู้พัฒนาที่เชื่อถือได้อื่นๆ) เลือกเวอร์ชันล่าสุดแล้วคลิก “Install”
5. ข้อควรระวัง: หากเคยติดตั้งไลบรารี LiquidCrystal_I2C อื่นๆ มาก่อน ควรลบไลบรารีเหล่านั้นออกก่อนที่จะติดตั้งเวอร์ชันใหม่ เพื่อป้องกันปัญหาความขัดแย้งของไลบรารี

ฟังก์ชันสำคัญในไลบรารี LiquidCrystal_I2C

ฟังก์ชันส่วนใหญ่ในไลบรารี LiquidCrystal_I2C จะคล้ายคลึงกับ LiquidCrystal แต่มีข้อแตกต่างที่สำคัญในการประกาศอ็อบเจกต์และการควบคุมไฟ Backlight:

• #include <Wire.h> และ #include <LiquidCrystal_I2C.h>: ต้องเรียกใช้งานทั้งสองไลบรารีนี้ที่ส่วนบนสุดของโค้ด
• LiquidCrystal_I2C lcd(i2c_address, cols, rows);: ใช้ในการประกาศอ็อบเจกต์ LCD
  • i2c_address: คือ I2C Address ที่ได้จากการสแกน (เช่น 0x27 หรือ 0x3F)
  • cols: จำนวนคอลัมน์ของจอ LCD (เช่น 16 สำหรับจอ 16×2)
  • rows: จำนวนแถวของจอ LCD (เช่น 2 สำหรับจอ 16×2)
• lcd.init();: ฟังก์ชันนี้จำเป็นต้องเรียกใช้ใน setup() เพื่อเริ่มต้นการทำงานของจอ LCD หากไม่เรียกใช้ จออาจไม่แสดงผล
• lcd.backlight(); / lcd.noBacklight();: ใช้สำหรับเปิดหรือปิดไฟ Backlight ของจอ LCD
• ฟังก์ชันอื่นๆ: เช่น lcd.setCursor(), lcd.print(), lcd.clear(), lcd.home() และฟังก์ชันอื่นๆ ส่วนใหญ่จะทำงานเหมือนกับไลบรารี LiquidCrystal มาตรฐาน

ตัวอย่างโค้ด “Hello World!” (การเชื่อมต่อแบบ I2C)

โค้ดตัวอย่างนี้จะแสดงข้อความ “Hello World!” บนบรรทัดแรก และ “Arduino I2C” บนบรรทัดที่สอง

#include <Wire.h> // ไลบรารีสำหรับการสื่อสาร I2C
#include <LiquidCrystal_I2C.h> // ไลบรารีสำหรับควบคุม I2C LCD

// กำหนดค่าสำหรับอ็อบเจกต์ LCD:
// LiquidCrystal_I2C lcd(I2C_Address, จำนวนคอลัมน์, จำนวนแถว);
// ตรวจสอบ I2C Address ของคุณด้วยโค้ด I2C Scanner หากไม่ใช่ 0x27
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init(); // เริ่มต้นการทำงานของจอ LCD
  lcd.backlight(); // เปิดไฟ Backlight

  // กำหนดตำแหน่งเคอร์เซอร์ไปที่คอลัมน์ 2, แถว 0 (บรรทัดแรก)
  lcd.setCursor(2, 0);
  // พิมพ์ข้อความ "Hello World!"
  lcd.print("Hello World!");

  // กำหนดตำแหน่งเคอร์เซอร์ไปที่คอลัมน์ 0, แถว 1 (บรรทัดที่สอง)
  lcd.setCursor(0, 1);
  // พิมพ์ข้อความ "Arduino I2C"
  lcd.print("Arduino I2C");
}

void loop() {
  // ไม่มีการทำงานเพิ่มเติมใน loop สำหรับตัวอย่างนี้
}

ส่วนที่ 4: การแก้ไขปัญหาที่พบบ่อยในการใช้งานจอ LCD

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

4.1 จอแสดงผลเป็นแถบสี่เหลี่ยมสีดำทั้งหมด หรือไม่มีข้อความใดๆ

นี่เป็นปัญหาที่พบบ่อยที่สุดประการหนึ่งที่ผู้เริ่มต้นมักจะเจอ จออาจจะสว่างขึ้นและแสดงเป็นแถบสี่เหลี่ยมสีดำเต็มบรรทัด หรืออาจจะไม่มีอะไรแสดงเลยนอกจากไฟ Backlight

สาเหตุที่เป็นไปได้:

• การปรับความคมชัด (Contrast) ไม่ถูกต้อง: ตัวต้านทานปรับค่าได้ (Potentiometer) ที่ขา V0/VEE (สำหรับ Parallel) หรือบนโมดูล I2C (สำหรับ I2C) ไม่ได้ถูกปรับให้อยู่ในตำแหน่งที่เหมาะสม หากปรับมากเกินไปอาจเห็นเป็นแถบดำทั้งหมด หากปรับน้อยเกินไปอาจมองไม่เห็นตัวอักษร
• I2C Address ไม่ถูกต้อง (สำหรับ I2C LCD): หากใช้ I2C LCD และ Address ที่ระบุในโค้ดไม่ตรงกับ Address จริงของโมดูล จอจะไม่สามารถสื่อสารกับ Arduino ได้
• สายไฟหลวมหรือไม่ถูกต้อง: การเชื่อมต่อสายไฟไม่แน่นหนา หรือมีการต่อผิดขา (โดยเฉพาะในโหมด Parallel ที่มีสายจำนวนมาก) อาจทำให้ข้อมูลไม่สามารถส่งถึงจอได้อย่างสมบูรณ์ [33, 34]
• ไม่ได้เรียกใช้ lcd.init(); (สำหรับ I2C LCD): ฟังก์ชัน init() เป็นสิ่งจำเป็นในการเริ่มต้นการทำงานของโมดูล I2C LCD หากขาดไป จอจะไม่ทำงาน
• จอ LCD เสียหาย: ในบางกรณี จอ LCD อาจชำรุดเสียหายจากโรงงาน หรือจากการใช้งานที่ไม่เหมาะสม (เช่น การจ่ายไฟเกิน)

แนวทางแก้ไข:

• ปรับ Potentiometer: ค่อยๆ หมุนตัวต้านทานปรับค่าได้บนวงจรหรือบนโมดูล I2C LCD ช้าๆ จนกว่าจะเห็นตัวอักษรหรือแถบสี่เหลี่ยมปรากฏชัดเจน
• ตรวจสอบ I2C Address: หากใช้ I2C LCD ให้ใช้โค้ด I2C Scanner (ตามที่อธิบายในหัวข้อ 3.4) เพื่อค้นหา Address ที่ถูกต้องของโมดูล แล้วนำไปแก้ไขในโค้ด LiquidCrystal_I2C lcd(0xXX, 16, 2);
• ตรวจสอบการเชื่อมต่อสายไฟ: ตรวจสอบแผนภาพวงจรอย่างละเอียดและตรวจสอบการเชื่อมต่อสายไฟทุกเส้นอีกครั้งว่าแน่นหนาและตรงตามขาที่กำหนดหรือไม่ ลองเปลี่ยนสายไฟใหม่หากสงสัยว่าสายเดิมอาจมีปัญหา
• ตรวจสอบโค้ด init(): ตรวจสอบให้แน่ใจว่าได้เรียกใช้ lcd.init(); ในฟังก์ชัน setup() ของโค้ดสำหรับ I2C LCD

4.2 ข้อความแสดงผลผิดเพี้ยน หรือมีการกระพริบ

บางครั้งจอ LCD อาจแสดงข้อความที่ไม่ถูกต้อง ตัวอักษรเพี้ยน หรือมีการกระพริบผิดปกติ

สาเหตุที่เป็นไปได้:

• ปัญหา Timing ในการสื่อสาร I2C: การสื่อสาร I2C มีความอ่อนไหวต่อ Timing [35] หากมี Interrupts อื่นๆ เกิดขึ้นระหว่างการสื่อสาร หรือฟังก์ชัน delay() ที่ใช้ในโค้ดไม่ได้เป็น “true delay” (เช่น ในบางแพลตฟอร์มที่ delay() อาจมีการทำงานเบื้องหลังอื่น) อาจทำให้ข้อมูลเสียหายได้
• การใช้ String objects มากเกินไป: การใช้คลาส String ใน Arduino มากเกินไปอาจทำให้เกิดปัญหา Heap Fragmentation (หน่วยความจำกระจัดกระจาย) ซึ่งอาจส่งผลต่อความเสถียรของระบบและทำให้การแสดงผลผิดเพี้ยนได้
• Library ไม่เข้ากันหรือไม่ถูกต้อง: การใช้ไลบรารี LiquidCrystal_I2C ที่ไม่เหมาะสมกับโมดูล I2C Adapter หรือชิปขยายพอร์ต I/O ที่ใช้ อาจทำให้เกิดปัญหาการสื่อสาร
• Pull-up Resistors ไม่เหมาะสม: บัส I2C ต้องการ Pull-up Resistors บนสาย SDA และ SCL โมดูล I2C LCD ส่วนใหญ่จะมี Pull-up Resistors มาให้ในตัวแล้ว แต่หากมีการต่อ Pull-up เพิ่มเติมอย่างไม่เหมาะสม อาจทำให้เกิดปัญหาได้

แนวทางแก้ไข:

• ตรวจสอบ Library: ตรวจสอบให้แน่ใจว่าได้ใช้ไลบรารี LiquidCrystal_I2C ที่แนะนำและเข้ากันได้กับโมดูลของคุณ หากสงสัย ให้ลองลบไลบรารีที่ซ้ำซ้อนออกแล้วติดตั้งใหม่
• ลอง lcd.init() ซ้ำ: ในบางกรณี การเรียก lcd.init(); ซ้ำเป็นระยะๆ ในฟังก์ชัน loop() อาจช่วยแก้ไขปัญหาข้อความผิดเพี้ยนได้ชั่วคราว แต่ไม่ใช่แนวทางแก้ไขที่ถาวรและอาจส่งผลต่อความสวยงามของการแสดงผล [35]
• หลีกเลี่ยงการใช้ String objects มากเกินไป: หากเป็นไปได้ ให้เปลี่ยนไปใช้ char (C-style strings) แทนคลาส String เพื่อลดปัญหา Heap Fragmentation
• ตรวจสอบ Pull-up Resistors: ตรวจสอบว่าโมดูล I2C LCD มี Pull-up Resistors ในตัวหรือไม่ และหลีกเลี่ยงการต่อ Pull-up Resistors เพิ่มเติมจากภายนอกหากไม่จำเป็น

4.3 ไม่สามารถอัปโหลดโค้ด หรือ Library Error

ปัญหาที่เกี่ยวข้องกับการคอมไพล์โค้ดหรือการอัปโหลดไปยัง Arduino

สาเหตุที่เป็นไปได้:

• ติดตั้ง Library ไม่ถูกต้อง: ไลบรารีอาจไม่ถูกติดตั้งในตำแหน่งที่ถูกต้อง หรือไฟล์เสียหาย [4, 14, 20, 27]
• มี Library ชื่อซ้ำกัน: หากมีไลบรารีหลายตัวที่มีชื่อไฟล์หรือโฟลเดอร์คล้ายกัน Arduino IDE อาจสับสนและเลือกใช้ไลบรารีที่ไม่ถูกต้อง ทำให้เกิดข้อผิดพลาดในการคอมไพล์
• เวอร์ชัน Arduino IDE ไม่เข้ากัน: บางไลบรารีอาจไม่เข้ากันกับ Arduino IDE เวอร์ชันเก่าหรือใหม่เกินไป [20]

แนวทางแก้ไข:

• ตรวจสอบและลบ Library ที่ซ้ำซ้อน: ไปที่โฟลเดอร์ libraries ในไดเรกทอรีการติดตั้ง Arduino IDE ของคุณ และตรวจสอบว่ามีโฟลเดอร์ LiquidCrystal_I2C หรือชื่อที่คล้ายกันหลายโฟลเดอร์หรือไม่ หากมี ให้ลบโฟลเดอร์ที่ไม่ต้องการออก
• ติดตั้ง Library ที่แนะนำใหม่: ทำการติดตั้งไลบรารี LiquidCrystal_I2C ตามขั้นตอนที่แนะนำในหัวข้อ 3.5 อีกครั้งอย่างระมัดระวัง [4, 14, 20]
• ตรวจสอบเวอร์ชัน Arduino IDE: หากปัญหายังคงอยู่ ลองใช้ Arduino IDE เวอร์ชันที่แตกต่างกัน (เก่ากว่าหรือใหม่กว่า) เพื่อดูว่าปัญหาได้รับการแก้ไขหรือไม่

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

สรุปและข้อเสนอแนะ

บทความนี้ได้นำเสนอภาพรวมเกี่ยวกับการทำงานของจอ LCD แบบตัวอักษร โดยเริ่มต้นจากหลักการพื้นฐานของผลึกเหลว โครงสร้างภายในของชิปควบคุม Hitachi HD44780 ซึ่งเป็นหัวใจสำคัญของการแสดงผล และหน้าที่ของขาต่างๆ บนจอ LCD การทำความเข้าใจสถาปัตยกรรมภายในของ HD44780 โดยเฉพาะหน่วยความจำ DDRAM และ CGRAM ช่วยให้เราสามารถเข้าใจได้ว่าไลบรารี Arduino ทำงานอย่างไรในการจัดการข้อมูลและคำสั่งระดับต่ำ ซึ่งเป็นพื้นฐานสำคัญในการควบคุมการแสดงผลได้อย่างแม่นยำ รวมถึงการสร้างตัวอักษรพิเศษที่กำหนดเองได้

เราได้สำรวจวิธีการเชื่อมต่อจอ LCD กับบอร์ด Arduino Uno R3 ในสองรูปแบบหลัก ได้แก่ การเชื่อมต่อแบบขนาน (Parallel Interface) ซึ่งแม้จะใช้ขา Digital I/O จำนวนมาก (7 ขาสำหรับโหมด 4-bit) แต่ก็ให้การควบคุมโดยตรงและมีความเร็วในการส่งข้อมูลที่ดี และการเชื่อมต่อผ่านโมดูล I2C (I2C Interface) ซึ่งเป็นที่นิยมอย่างมากในปัจจุบัน เนื่องจากสามารถลดจำนวนสายไฟที่ใช้ในการเชื่อมต่อลงได้อย่างมาก (เหลือเพียง 4 เส้นรวมไฟเลี้ยง) ทำให้การเดินสายง่ายขึ้น ลดความซับซ้อนของวงจร และประหยัดขา I/O ของ Arduino ได้อย่างมหาศาล ซึ่งเป็นประโยชน์อย่างยิ่งสำหรับโครงการที่มีอุปกรณ์ต่อพ่วงหลายชิ้น แม้ว่า I2C จะมีอัตราการถ่ายโอนข้อมูลที่ช้ากว่าเล็กน้อย แต่ก็เพียงพอสำหรับการแสดงผลข้อความบนจอ LCD แบบตัวอักษร นอกจากนี้ เรายังได้เรียนรู้การใช้งานไลบรารี LiquidCrystal.h สำหรับการเชื่อมต่อแบบขนาน และ LiquidCrystal_I2C.h สำหรับการเชื่อมต่อแบบ I2C พร้อมด้วยโค้ดตัวอย่างที่สามารถนำไปปรับใช้ได้ทันที รวมถึงแนวทางการแก้ไขปัญหาที่พบบ่อย เช่น จอแสดงผลเป็นแถบสีดำ ข้อความผิดเพี้ยน หรือปัญหาการติดตั้งไลบรารี การมีความรู้เหล่านี้จะช่วยให้นักเรียนและผู้สนใจสามารถเริ่มต้นทำงานกับจอ LCD ได้อย่างราบรื่นและแก้ไขปัญหาที่อาจเกิดขึ้นได้อย่างมีประสิทธิภาพ