การเชื่อมต่อจอแอลซีดี Arduino nano i2c การเชื่อมต่อหน้าจอ LCD LCM1602 กับ I2C เข้ากับ Arduino โปรแกรมสร้างสัญลักษณ์อย่างง่าย

โปรแกรมสร้างสัญลักษณ์อย่างง่าย

ในความคิดเห็น สมาชิกชุมชนได้ส่งลิงก์ไปยังเครื่องสร้างสัญลักษณ์

• โมดูล FC-113 ใช้ชิป PCF8574T ซึ่งเป็นรีจิสเตอร์กะ 8 บิต - "ตัวขยาย" อินพุต - เอาท์พุตสำหรับ บัสอนุกรมไอทูซี ในรูปไมโครวงจรถูกกำหนดให้เป็น DD1
• R1 เป็นตัวต้านทานแบบทริมสำหรับปรับคอนทราสต์ของจอ LCD
• Jumper J1 ใช้เพื่อเปิดไฟแบ็คไลท์ของจอแสดงผล
• พิน 1…16 ใช้สำหรับเชื่อมต่อโมดูลกับพินของจอแสดงผล LCD
• ต้องใช้คอนแทคแพด A1...A3 เพื่อเปลี่ยนที่อยู่ I2C ของอุปกรณ์ คุณสามารถเปลี่ยนที่อยู่ของอุปกรณ์ได้โดยการบัดกรีจัมเปอร์ที่เหมาะสม ตารางแสดงความสอดคล้องของที่อยู่และจัมเปอร์: “0” สอดคล้องกับวงจรเปิด “1” ถึงจัมเปอร์ที่ติดตั้งไว้ ตามค่าเริ่มต้น จัมเปอร์ทั้ง 3 ตัวจะเปิดอยู่และที่อยู่ของอุปกรณ์ 0x27.

2 แผนภาพการเชื่อมต่อจอแสดงผล LCD กับ Arduinoผ่านโปรโตคอล I2C

โมดูลเชื่อมต่อกับ Arduino ด้วยวิธีมาตรฐานสำหรับบัส I2C: พิน SDA ของโมดูลเชื่อมต่อกับพอร์ตอะนาล็อก A4, พิน SCL เชื่อมต่อกับพอร์ตอะนาล็อก A5 ของ Arduino โมดูลนี้ใช้พลังงานจาก +5 V จาก Arduino ตัวโมดูลเชื่อมต่อกันด้วยพิน 1…16 กับพินที่เกี่ยวข้อง 1…16 บนจอแสดงผล LCD

3 ห้องสมุดเพื่อการทำงานผ่านโปรโตคอล I2C

ตอนนี้เราต้องการไลบรารีเพื่อทำงานกับ LCD ผ่านทางอินเทอร์เฟซ I2C คุณสามารถใช้อันนี้ได้ (ลิงก์ในบรรทัด "ดาวน์โหลดโค้ดตัวอย่างและไลบรารี")

ดาวน์โหลดไฟล์เก็บถาวรแล้ว LiquidCrystal_I2Cv1-1.rarคลายซิปไปที่โฟลเดอร์ \ห้องสมุด\ซึ่งอยู่ในไดเร็กทอรี Arduino IDE

ไลบรารีรองรับชุดฟังก์ชันมาตรฐานสำหรับหน้าจอ LCD:

4 ร่างสำหรับการส่งออกข้อความไปยังหน้าจอ LCD ผ่านบัส I2C

มาเปิดตัวอย่าง: ตัวอย่างไฟล์ LiquidCrystal_I2C CustomCharsและเราจะเปลี่ยนแปลงมันเล็กน้อย เราจะแสดงข้อความตอนท้ายซึ่งจะมีสัญลักษณ์กะพริบ ความคิดเห็นต่อรหัสแสดงความคิดเห็นเกี่ยวกับความแตกต่างของร่างทั้งหมด

#รวม // รวมไลบรารี Wire #include // เชื่อมต่อไลบรารี LCD #define printByte(args) write(args); // หัวใจ uint8_t = (0x0,0xa,0x1f,0x1f,0xe,0x4,0x0); // บิตมาส์กของสัญลักษณ์ "หัวใจ" LiquidCrystal_I2C lcd (0x27, 16, 2); // ตั้งค่าที่อยู่ 0x27 สำหรับจอ LCD 16x2 การตั้งค่าเป็นโมฆะ () (จอแอลซีดี.init(); // การเริ่มต้นจอแสดงผล LCD lcd.backlight(); // เปิดไฟแบ็คไลท์ของจอแสดงผล lcd.createChar(3, หัวใจ); // สร้างสัญลักษณ์ “หัวใจ” ในเซลล์หน่วยความจำ 3 lcd.home(); // วางเคอร์เซอร์ที่มุมซ้ายบน ที่ตำแหน่ง (0,0) lcd.!"); // พิมพ์บรรทัดข้อความ lcd.setCursor(0, 1); // เลื่อนเคอร์เซอร์ไปที่บรรทัด 2 อักขระ 1 lcd.print( " i "); // พิมพ์ข้อความในบรรทัดที่ 2 lcd.printByte(3); // พิมพ์สัญลักษณ์ "หัวใจ" ที่อยู่ในเซลล์ที่ 3 lcd.print(" Arduino "); } เป็นโมฆะวน() (// กระพริบอักขระตัวสุดท้าย lcd.setCursor(13, 1); // เลื่อนเคอร์เซอร์ไปที่บรรทัดที่ 2 อักขระ 1 lcd.print("\t"); ล่าช้า (500); จอแอลซีดี setCursor (13, 1); // เลื่อนเคอร์เซอร์ไปที่บรรทัดที่ 2 อักขระ 1 lcd.print(" "); ล่าช้า (500); }

โดยวิธีการเขียนตัวอักษรตามคำสั่ง จอแอลซีดี. createChar();ยังคงอยู่ในหน่วยความจำจอแสดงผลแม้หลังจากปิดเครื่องแล้วเพราะว่า เขียนเพื่อแสดง ROM 1602

5 สร้างสัญลักษณ์ของคุณเองสำหรับจอ LCD

มาดูปัญหาการสร้างสัญลักษณ์ของคุณเองสำหรับหน้าจอ LCD กันดีกว่า อักขระแต่ละตัวบนหน้าจอประกอบด้วย 35 จุด: กว้าง 5 จุดและสูง 7 จุด (+1 บรรทัดสำรองสำหรับการขีดเส้นใต้) ในบรรทัดที่ 6 ของภาพร่างด้านบน เรากำหนดอาร์เรย์ของตัวเลข 7 ตัว: (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0)- แปลงเลขฐานสิบหกเป็นไบนารี่: {00000, 01010, 11111, 11111, 01110, 00100, 00000} - ตัวเลขเหล่านี้ไม่ใช่อะไรมากไปกว่าบิตมาสก์สำหรับแต่ละบรรทัดทั้ง 7 บรรทัดของสัญลักษณ์ โดยที่ "0" หมายถึงจุดสว่าง และ "1" หมายถึงจุดมืด ตัวอย่างเช่น สัญลักษณ์รูปหัวใจที่ระบุเป็นบิตมาสก์จะปรากฏบนหน้าจอดังแสดงในรูป

6 การควบคุมหน้าจอ LCDผ่านบัส I2C

มาอัพโหลดภาพร่างไปยัง Arduino กัน คำจารึกที่เราระบุด้วยเคอร์เซอร์กะพริบที่ส่วนท้ายจะปรากฏบนหน้าจอ

7 อะไรอยู่ข้างหลังบัส I2C

นอกจากนี้ เรามาดูแผนภาพเวลาสำหรับการแสดงอักขระละติน "A", "B" และ "C" บนจอแสดงผล LCD อักขระเหล่านี้จะถูกจัดเก็บไว้ใน ROM การแสดงผลและแสดงบนหน้าจอเพียงแค่ส่งที่อยู่ไปยังจอแสดงผล แผนภาพนี้นำมาจากพิน RS, RW, E, D4, D5, D6 และ D7 ของจอแสดงผลเช่น หลังจากตัวแปลง "บัสขนาน I2C" ของ FC-113 แล้ว เราสามารถพูดได้ว่าเรากำลังเจาะลึกเข้าไปในฮาร์ดแวร์อีกเล็กน้อย

แผนภาพแสดงให้เห็นว่าอักขระที่อยู่ใน ROM การแสดงผล (ดูหน้า 11 ของแผ่นข้อมูลลิงก์ด้านล่าง) จะถูกส่งเป็นสอง nibbles โดยตัวแรกจะกำหนดหมายเลขคอลัมน์ของตารางและตัวที่สอง - หมายเลขแถว ในกรณีนี้ ข้อมูลจะถูก "ล็อค" ที่ขอบของสัญญาณบนเส้น อี(เปิดใช้งาน) และเส้น อาร์.เอส.(เลือกการลงทะเบียน) อยู่ในสถานะหนึ่งแบบลอจิคัล ซึ่งหมายความว่าข้อมูลกำลังถูกถ่ายโอน สถานะต่ำบนบรรทัด RS หมายความว่าคำสั่งกำลังถูกส่ง ซึ่งเป็นสิ่งที่เราเห็นก่อนที่จะส่งอักขระแต่ละตัว ในกรณีนี้ รหัสคำสั่งการคืนแคร่ตลับหมึกจะถูกส่งไปยังตำแหน่ง (0, 0) ของจอ LCD ซึ่งสามารถค้นหาได้จากการศึกษาเช่นกัน รายละเอียดทางเทคนิคแสดง.

และอีกตัวอย่างหนึ่ง แผนภาพเวลานี้แสดงเอาท์พุตของสัญลักษณ์รูปหัวใจบนจอ LCD

อีกครั้งสองแรงกระตุ้นแรก เปิดใช้งานปฏิบัติตามคำแนะนำ บ้าน()(0000 0010 2) - กลับแคร่ไปที่ตำแหน่ง (0; 0) และสองอันที่สอง - เอาต์พุตไปยังจอ LCD ที่เก็บไว้ในเซลล์หน่วยความจำ 3 10 (0000 0011 2) สัญลักษณ์ "หัวใจ" (คำแนะนำ lcd.createChar(3, หัวใจ);ร่าง).

จอ LCD– แขกประจำในโครงการ Arduino แต่ใน แผนการที่ซับซ้อนเราอาจมีปัญหาการขาดพอร์ต Arduino เนื่องจากจำเป็นต้องเชื่อมต่อชิลด์ที่มีพินจำนวนมาก วิธีแก้ปัญหาในสถานการณ์นี้อาจเป็นได้ I2C/IICอะแดปเตอร์ที่เชื่อมต่อเกือบมาตรฐานสำหรับ หน้าจออาดูโน่ 1602 ถึงบอร์ด Uno, Nano หรือ Mega ที่มีเพียง 4 พิน ในบทความนี้เราจะมาดูกันว่าคุณสามารถเชื่อมต่อหน้าจอ LCD กับอินเทอร์เฟซ I2C ได้อย่างไร ไลบรารีใดที่คุณสามารถใช้ เขียนตัวอย่างแบบร่างสั้น ๆ และดูข้อผิดพลาดทั่วไป

จอแสดงผลคริสตัลเหลว จอแอลซีดี 1602เป็น ทางเลือกที่ดีเพื่อส่งออกสตริงอักขระในโครงการต่างๆ มีราคาไม่แพง มีการดัดแปลงต่างๆ ด้วยสีแบ็คไลท์ที่แตกต่างกัน คุณสามารถดาวน์โหลดไลบรารี่สำเร็จรูปสำหรับสเก็ตช์ Arduino ได้อย่างง่ายดาย แต่ข้อเสียที่สำคัญที่สุดของหน้าจอนี้คือความจริงที่ว่าจอแสดงผลมีพินดิจิทัล 16 อันซึ่งจำเป็นต้องมีอย่างน้อย 6 อัน ดังนั้นการใช้สิ่งนี้ หน้าจอแอลซีดีหากไม่มี i2c จะเพิ่มข้อจำกัดร้ายแรงสำหรับบอร์ด Arduino Uno หรือ Nano หากมีผู้ติดต่อไม่เพียงพอ คุณจะต้องซื้อบอร์ด Arduino Mega หรือบันทึกผู้ติดต่อ รวมถึงโดยการเชื่อมต่อจอแสดงผลผ่าน i2c

คำอธิบายโดยย่อของพิน LCD 1602

มาดูพิน LCD1602 กันดีกว่า:

หมุดแต่ละตัวมีจุดประสงค์ของตัวเอง:

1. กราวด์ GND;
2. แหล่งจ่ายไฟ 5 โวลต์;
3. การตั้งค่าความคมชัดของจอภาพ
4. คำสั่งข้อมูล;
5. การเขียนและการอ่านข้อมูล
6. เปิดใช้งาน;

7-14. สายข้อมูล

1. พร้อมแสงไฟหลัง;
2. ลบแสงไฟ

ข้อมูลจำเพาะของจอแสดงผล:

• ประเภทการแสดงตัวอักษร สามารถโหลดสัญลักษณ์ได้
• ไฟ LED;
• คอนโทรลเลอร์ HD44780;
• แรงดันไฟฟ้า 5V;
• จัดรูปแบบอักขระ 16x2;
• ช่วงอุณหภูมิในการทำงานตั้งแต่ -20C ถึง +70C อุณหภูมิการจัดเก็บตั้งแต่ -30C ถึง +80C;
• มุมมอง 180 องศา

แผนภาพการเชื่อมต่อของ LCD กับบอร์ด Arduino ที่ไม่มี i2C

แผนภาพมาตรฐานสำหรับการเชื่อมต่อจอภาพโดยตรงกับไมโครคอนโทรลเลอร์ Arduino ที่ไม่มี I2C มีดังนี้

เนื่องจากผู้ติดต่อที่เชื่อมต่ออยู่จำนวนมากอาจมีพื้นที่ไม่เพียงพอที่จะเชื่อมต่อองค์ประกอบที่จำเป็น การใช้ I2C จะช่วยลดจำนวนสายเหลือ 4 เส้นและพินว่างเหลือ 2 เส้น

หาซื้อได้ที่ไหน หน้าจอ LCD และชิลด์สำหรับ Arduino

หน้าจอ LCD 1602 (และเวอร์ชัน 2004) ค่อนข้างได้รับความนิยม คุณจึงสามารถค้นหาได้ง่ายทั้งในร้านค้าออนไลน์ในประเทศและในเว็บไซต์ต่างประเทศ ต่อไปนี้คือลิงก์บางส่วนไปยังตัวเลือกที่มีมากที่สุด:

โมดูลหน้าจอสีน้ำเงิน LCD1602+I2C รองรับ Arduino	จอแสดงผล LCD1602 แบบธรรมดา (แบ็คไลท์สีเขียว) ราคาถูกกว่า 80 รูเบิล	หน้าจอ LCD2004 ขนาดใหญ่พร้อม I2C HD44780 สำหรับ Arduino (ไฟแบ็คไลท์สีน้ำเงินและสีเขียว)
จอแสดงผล 1602 พร้อมอะแดปเตอร์ IIC และไฟแบ็คไลท์สีน้ำเงิน	LCD1602 อีกเวอร์ชันหนึ่งพร้อมโมดูล I2C บัดกรี	โมดูลอะแดปเตอร์พอร์ต IIC/I2C/TWI/SPI สำหรับโล่ 1602 เข้ากันได้กับ Arduino
จอแสดงผลแบ็คไลท์ RGB! LCD 16 × 2 + ปุ่มกด + Buzzer Shield สำหรับ Arduino	ชิลด์สำหรับ Arduino พร้อมปุ่มและหน้าจอ LCD1602 LCD 1602	จอแสดงผล LCD สำหรับเครื่องพิมพ์ 3D (ตัวควบคุมอัจฉริยะสำหรับ RAMPS 1.4, LCD ข้อความ 20×4), โมดูลตัวอ่านการ์ด SD และ MicroSD

คำอธิบายของโปรโตคอล I2C

ก่อนที่จะหารือเกี่ยวกับการเชื่อมต่อจอแสดงผลกับ Arduino ผ่านอะแดปเตอร์ i2c เรามาพูดคุยสั้น ๆ เกี่ยวกับโปรโตคอล i2C กันก่อน

I2C/IIC(Inter-Integrated Circuit) เป็นโปรโตคอลที่เดิมสร้างขึ้นเพื่อการสื่อสาร วงจรรวมภายในอุปกรณ์อิเล็กทรอนิกส์ การพัฒนาเป็นของฟิลิปส์ โปรโตคอล i2c ขึ้นอยู่กับการใช้บัส 8 บิตซึ่งจำเป็นสำหรับการสื่อสารบล็อกในอุปกรณ์อิเล็กทรอนิกส์ควบคุมและระบบการกำหนดที่อยู่ซึ่งคุณสามารถสื่อสารผ่านสายเดียวกันด้วยอุปกรณ์หลายตัว เราเพียงถ่ายโอนข้อมูลไปยังอุปกรณ์หนึ่งหรืออีกอุปกรณ์หนึ่งโดยเพิ่มตัวระบุองค์ประกอบที่ต้องการลงในแพ็กเก็ตข้อมูล

ที่สุด วงจรง่ายๆ I2C สามารถประกอบด้วยอุปกรณ์หลักหนึ่งตัว (ส่วนใหญ่มักจะเป็นไมโครคอนโทรลเลอร์ Arduino) และสเลฟหลายตัว (เช่น จอ LCD) อุปกรณ์แต่ละตัวมีที่อยู่อยู่ในช่วงตั้งแต่ 7 ถึง 127 ไม่ควรมีอุปกรณ์สองเครื่องที่มีที่อยู่เดียวกันในวงจรเดียวกัน

บอร์ด Arduino รองรับ i2c ในฮาร์ดแวร์ คุณสามารถใช้พิน A4 และ A5 เพื่อเชื่อมต่ออุปกรณ์โดยใช้โปรโตคอลนี้

มีข้อดีหลายประการสำหรับการทำงานของ I2C:

• การดำเนินการต้องการเพียง 2 บรรทัด - SDA (สายข้อมูล) และ SCL (สายซิงค์)
• เชื่อมต่ออุปกรณ์ชั้นนำมากมาย
• ลดเวลาในการพัฒนา
• ต้องใช้ไมโครคอนโทรลเลอร์เพียงตัวเดียวในการควบคุมอุปกรณ์ทั้งชุด
• จำนวนไมโครวงจรที่เป็นไปได้ที่เชื่อมต่อกับบัสหนึ่งถูกจำกัดด้วยความจุสูงสุดเท่านั้น
• ความปลอดภัยของข้อมูลระดับสูงเนื่องจากมีตัวกรองป้องกันไฟกระชากแบบพิเศษที่ติดตั้งอยู่ในวงจร
• ขั้นตอนง่ายๆ สำหรับการวินิจฉัยความล้มเหลวที่เกิดขึ้นและการแก้ไขข้อบกพร่องอย่างรวดเร็ว
• บัสได้รวมเข้ากับ Arduino แล้ว ดังนั้นจึงไม่จำเป็นต้องพัฒนาอินเทอร์เฟซบัสเพิ่มเติม

ข้อบกพร่อง:

• มีขีด จำกัด capacitive บนบรรทัด - 400 pF
• ยากต่อการตั้งโปรแกรมคอนโทรลเลอร์ I2C หากมีอุปกรณ์ที่แตกต่างกันหลายตัวบนบัส
• ที่ ปริมาณมากอุปกรณ์จะมีปัญหาในการระบุตำแหน่งข้อผิดพลาดหากอุปกรณ์ตัวใดตัวหนึ่งตั้งค่าสถานะระดับต่ำผิดพลาด

โมดูล i2c สำหรับ LCD 1602 Arduino

เร็วที่สุดและ วิธีที่สะดวกการใช้จอแสดงผล i2c ใน Arduino หมายถึงการซื้อหน้าจอสำเร็จรูปที่รองรับโปรโตคอลในตัว แต่มีหน้าจอเหล่านี้ไม่มากนักและไม่ถูก แต่มีการผลิตหน้าจอมาตรฐานที่แตกต่างกันจำนวนมากแล้ว ดังนั้นตัวเลือกที่เหมาะสมและเป็นที่นิยมมากที่สุดในปัจจุบันคือการซื้อและใช้โมดูล I2C แยกต่างหาก - อะแดปเตอร์ซึ่งมีลักษณะดังนี้:

ที่ด้านหนึ่งของโมดูล เราเห็นพิน i2c - กราวด์ กำลังไฟ และ 2 อันสำหรับการถ่ายโอนข้อมูล ในอะแดปเตอร์อื่นเราจะเห็นขั้วต่อไฟภายนอก และแน่นอนว่าบอร์ดมีหลายขาซึ่งโมดูลจะบัดกรีเข้ากับหมุดหน้าจอมาตรฐาน

เอาต์พุต i2c ใช้เชื่อมต่อกับบอร์ด Arduino หากจำเป็นให้เชื่อมต่อพลังงานภายนอกสำหรับไฟแบ็คไลท์ ด้วยทริมเมอร์ในตัว เราสามารถตั้งค่าคอนทราสต์แบบกำหนดเอง J ได้

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

การเชื่อมต่อหน้าจอ LCD เข้ากับ Arduino ผ่าน I2C

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

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

จอภาพ LCD ที่รองรับ i2c เชื่อมต่อกับบอร์ดโดยใช้สายไฟสี่เส้น - สองสายสำหรับข้อมูล, สายไฟสองเส้น

• พิน GND เชื่อมต่อกับ GND บนบอร์ด
• พิน VCC อยู่ที่ 5V
• SCL เชื่อมต่อกับขา A5
• SDA เชื่อมต่อกับขา A

และนั่นคือทั้งหมด! ไม่มีโครงลวดซึ่งพันกันได้ง่ายมาก ในเวลาเดียวกัน เราสามารถไว้วางใจความซับซ้อนทั้งหมดของการนำโปรโตคอล i2C ไปใช้กับไลบรารีได้

ไลบรารีสำหรับการทำงานกับจอแสดงผล LCD i2c

ในการโต้ตอบกับ Arduino และ LCD 1602 ผ่านบัส I2C คุณจะต้องมีไลบรารีอย่างน้อยสองไลบรารี:

• ไลบรารี Wire.h สำหรับการทำงานกับ I2C มีอยู่แล้วใน โปรแกรมมาตรฐานอาร์ดูโน่ IDE.
• ไลบรารี LiquidCrystal_I2C.h ซึ่งประกอบด้วยคำสั่งที่หลากหลายสำหรับการควบคุมจอภาพผ่านบัส I2C และช่วยให้คุณทำให้การสเก็ตช์ภาพง่ายขึ้นและสั้นลง คุณต้องติดตั้งไลบรารีเพิ่มเติม หลังจากเชื่อมต่อจอแสดงผลแล้ว คุณต้องติดตั้งไลบรารี LiquidCrystal_I2C.h เพิ่มเติม

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

#รวม #รวม // รวมถึงห้องสมุด //#include // การเชื่อมต่อไลบรารีสำรอง LiquidCrystal_I2C lcd (0x27,16,2); // ระบุที่อยู่ I2C (ค่าที่พบบ่อยที่สุด) รวมถึงพารามิเตอร์หน้าจอ (ในกรณีของ LCD 1602 - 2 บรรทัดละ 16 ตัวอักษร //LiquidCrystal_PCF8574 lcd(0x27); // ตัวเลือกสำหรับการตั้งค่าโมฆะไลบรารี PCF8574 ( ) ( lcd.init (); // เริ่มต้นการแสดงผล lcd.backlight(); // เชื่อมต่อแบ็คไลท์ lcd.setCursor(0,0); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดแรก lcd.print(" สวัสดี"); lcd.setCursor(0,1); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดที่สอง lcd.print("ArduinoMaster"); // พิมพ์ข้อความในบรรทัดที่สอง ) void loop() ( )

คำอธิบายฟังก์ชันและวิธีการของไลบรารี LiquidCrystal_I2C:

• home() และ clear() - ฟังก์ชั่นแรกช่วยให้คุณสามารถคืนเคอร์เซอร์ไปที่จุดเริ่มต้นของหน้าจอส่วนที่สองก็ทำเช่นเดียวกัน แต่ในขณะเดียวกันก็ลบทุกอย่างที่อยู่บนหน้าจอก่อนหน้านี้
• write(ch) - อนุญาตให้คุณพิมพ์อักขระตัวเดียว ch ไปที่หน้าจอ
• cursor() และ noCursor() – แสดง/ซ่อนเคอร์เซอร์บนหน้าจอ
• กะพริบ() และ noBlink() - เคอร์เซอร์กะพริบ/ไม่กะพริบ (หากเปิดใช้งานจอแสดงผลก่อนหน้านี้)
• display() และ noDisplay() – ให้คุณเชื่อมต่อ/ปิดการใช้งานจอแสดงผล
• scrollDisplayLeft() และ scrollDisplayRight() – เลื่อนหน้าจอไปทางซ้าย/ขวาหนึ่งอักขระ
• autoscroll() และ noAutoscroll() - ช่วยให้คุณสามารถเปิด/ปิดโหมดเลื่อนอัตโนมัติได้ ในโหมดนี้นะทุกคน สัญลักษณ์ใหม่เขียนอยู่ในที่เดียวกันแทนที่สิ่งที่เขียนบนหน้าจอก่อนหน้านี้
• leftToRight() และ rightToLeft() – การตั้งค่าทิศทางของข้อความที่แสดง – ซ้ายไปขวา หรือ ขวาไปซ้าย
• createChar(ch, บิตแมป) – สร้างอักขระด้วยโค้ด ch (0 – 7) โดยใช้อาร์เรย์บิตแมปเพื่อสร้างจุดขาวดำ

ไลบรารีทางเลือกสำหรับการทำงานกับจอแสดงผล i2c

ในบางกรณีอาจเกิดข้อผิดพลาดเมื่อใช้ไลบรารีที่ระบุกับอุปกรณ์ที่ติดตั้งคอนโทรลเลอร์ PCF8574 ในกรณีนี้ สามารถแนะนำไลบรารี LiquidCrystal_PCF8574.h เป็นทางเลือกได้ มันขยาย LiquidCrystal_I2C ดังนั้นจึงไม่น่าจะมีปัญหาในการใช้งาน

ปัญหาการเชื่อมต่อจอแสดงผล LCD i2c

หากหลังจากอัปโหลดภาพสเก็ตช์แล้ว คุณไม่เห็นข้อความใด ๆ บนจอแสดงผล ให้ลองทำตามขั้นตอนต่อไปนี้

ขั้นแรก คุณสามารถเพิ่มหรือลดคอนทราสต์ของจอภาพได้ บ่อยครั้งที่อักขระไม่สามารถมองเห็นได้เนื่องจากโหมดคอนทราสต์และแบ็คไลท์

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

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

หากหน้าจอยังคงใช้งานไม่ได้ ให้ลองถอดอะแดปเตอร์ออกแล้วเชื่อมต่อ LCD ตามปกติ

บทสรุป

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

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

จอแอลซีดี 1602

ในบรรดาตัวเลือกต่างๆ ของจอแสดงผล ฉันอยากจะพูดถึงจอแสดงผล LCD1602 ที่ใช้คอนโทรลเลอร์ HD4478 โดยเฉพาะ จอแสดงผลนี้มีให้เลือกสองสี: ตัวอักษรสีขาวบนพื้นหลังสีน้ำเงิน ตัวอักษรสีดำบนพื้นหลังสีเหลือง การเชื่อมต่อ LCD 1602 กับ Arduino จะไม่ทำให้เกิดปัญหาใด ๆ เนื่องจากมีไลบรารี่ในตัวและไม่จำเป็นต้องดาวน์โหลดอะไรเพิ่มเติม จอแสดงผลแตกต่างกันไม่เพียงแต่ในราคาเท่านั้น แต่ยังรวมถึงขนาดด้วย บ่อยครั้งที่นักวิทยุสมัครเล่นใช้ 16 x 2 นั่นคือ 2 บรรทัดจำนวน 16 ตัวอักษร แต่ก็มีขนาด 20 x 4 เช่นกัน โดยจะมี 4 บรรทัดๆ ละ 20 ตัวอักษร ขนาดและสีไม่ได้มีบทบาทใดๆ ในการเชื่อมต่อจอแสดงผล lcd 1602 กับ Arduno โดยเชื่อมต่อในลักษณะเดียวกัน มุมมองคือ 35 องศา เวลาตอบสนองของจอแสดงผลคือ 250 ms สามารถทำงานได้ที่อุณหภูมิ -20 ถึง 70 องศาเซลเซียส ระหว่างการทำงาน จะใช้ 4 mA สำหรับหน้าจอ และ 120 mA สำหรับแบ็คไลท์

มันใช้ที่ไหน?

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

การเชื่อมต่อกับ Arduino

การเชื่อมต่อ LCD 1602 กับ Arduino Nano และ Uno ก็ไม่แตกต่างกัน คุณสามารถทำงานกับจอแสดงผลในสองโหมด: 4 บิตและ 8 เมื่อทำงานกับ 8 บิตจะใช้ทั้งบิตลำดับต่ำและลำดับสูง และสำหรับ 4 บิตจะใช้เฉพาะบิตลำดับต่ำเท่านั้น ไม่มีจุดใดในการทำงานกับ 8 บิตเนื่องจากจะเพิ่มผู้ติดต่ออีก 4 รายสำหรับการเชื่อมต่อซึ่งไม่แนะนำให้เลือกเนื่องจากความเร็วจะไม่สูงขึ้นขีด จำกัด สำหรับการอัปเดตการแสดงผลคือ 10 ครั้งต่อวินาที โดยทั่วไปในการเชื่อมต่อ lcd 1602 กับ Arduino ต้องใช้สายไฟจำนวนมากซึ่งทำให้เกิดความไม่สะดวก แต่มีเกราะป้องกันพิเศษ แต่จะเพิ่มเติมในภายหลัง ภาพถ่ายแสดงการเชื่อมต่อจอแสดงผลกับ Arduino Uno:

รหัสตัวอย่าง:

#รวม // เพิ่มไลบรารี LiquidCrystal ที่จำเป็น (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) การตั้งค่าเป็นโมฆะ())( lcd.begin(16, 2); // ตั้งค่าขนาดหน้าจอ lcd.setCursor(0, 0); // ตั้งเคอร์เซอร์ ไปที่จุดเริ่มต้น 1 บรรทัด lcd.print("Hello, world!"); // พิมพ์ข้อความ lcd.setCursor(0, 1); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัด 2 lcd.print("site") ; // พิมพ์ข้อความ ) void loop ()( )

รหัสทำอะไร? ขั้นตอนแรกคือการเชื่อมต่อไลบรารีเพื่อทำงานกับจอแสดงผล ตามที่กล่าวไว้ข้างต้น ไลบรารีนี้รวมอยู่ใน Arduino IDE แล้ว และไม่จำเป็นต้องดาวน์โหลดและติดตั้งเพิ่มเติม จากนั้นกำหนดรายชื่อผู้ติดต่อที่เชื่อมต่อกับพิน: RS, E, DB4, DB5, DB6, DB7 ตามลำดับ จากนั้นจึงกำหนดขนาดหน้าจอ เนื่องจากเรากำลังทำงานกับเวอร์ชันที่มี 16 ตัวอักษรและ 2 บรรทัด เราจึงเขียนค่าต่อไปนี้ เราวางเคอร์เซอร์ไว้ที่จุดเริ่มต้นของบรรทัดแรกและแสดงข้อความแรกของเราว่า Hello World จากนั้นวางเคอร์เซอร์บนบรรทัดที่สองแล้วแสดงชื่อไซต์ นั่นคือทั้งหมด! กำลังพิจารณาการเชื่อมต่อ lcd 1602 กับ Arduino Uno

I2C คืออะไร และเหตุใดจึงจำเป็น

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

การเชื่อมต่อโดยใช้โมดูล I2C

การเชื่อมต่อ LCD 1602 กับ Arduino Nano ด้วย I2C ใช้พื้นที่น้อย เพียง 4 พิน: กราวด์ กำลังไฟ และเอาต์พุตข้อมูล 2 ช่อง เราเชื่อมต่อพลังงานและกราวด์กับ 5V และ GND บน Arduino ตามลำดับ เราเชื่อมต่อผู้ติดต่อสองรายที่เหลือ: SCL และ SDA เข้ากับพินอะนาล็อก ในภาพคุณสามารถดูตัวอย่างการเชื่อมต่อ lcd 1602 กับ arduino ด้วยโมดูล I2C:

รหัสโปรแกรม

หากต้องทำงานกับจอแสดงผลโดยไม่มีโมดูล จำเป็นต้องใช้ไลบรารีเพียงอันเดียว ดังนั้นในการทำงานกับโมดูล คุณต้องมีไลบรารี 2 อัน หนึ่งในนั้นรวมอยู่ใน Arduino IDE - Wire แล้ว ไลบรารีอื่น LiquidCrystal I2C จะต้องดาวน์โหลดแยกต่างหากและติดตั้ง ในการติดตั้งไลบรารีใน Arduino เนื้อหาของไฟล์เก็บถาวรที่ดาวน์โหลดจะต้องโหลดลงในโฟลเดอร์ไลบรารีรูท ตัวอย่างโค้ดโปรแกรมที่ใช้ I2C:

#รวม #รวม จอแอลซีดี LiquidCrystal_I2C (0x27,16,2); // ตั้งค่าการตั้งค่าโมฆะการแสดงผล() ( lcd.init(); lcd.backlight(); // เปิดไฟแบ็คไลท์ของจอแสดงผล lcd..setCursor(8, 1); lcd.print("LCD 1602"); ) void loop( ) ( // ตั้งเคอร์เซอร์ไปที่บรรทัดที่สองและอักขระศูนย์ lcd.setCursor(0, 1); // แสดงจำนวนวินาทีตั้งแต่ Arduino เริ่มทำงาน lcd.print(millis()/1000); )

อย่างที่คุณเห็นรหัสเกือบจะเหมือนกัน

จะเพิ่มสัญลักษณ์ของคุณเองได้อย่างไร?

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

ถ้า 0 - ไม่มีอะไรเลย ถ้า 1 - นี่คือพื้นที่ที่ทาสี ในตัวอย่างด้านบน คุณจะเห็นการสร้างสัญลักษณ์ "ยิ้มยิ้ม" การใช้โปรแกรมตัวอย่างใน Arduino จะมีลักษณะดังนี้:

#รวม #รวม // เพิ่มไลบรารี่ที่จำเป็น // บิตมาสก์ของสัญลักษณ์รอยยิ้ม byte smile = ( B00010, B00001, B11001, B00001, B11001, B00001, B00010, ); จอแอลซีดีลิควิดคริสตัล (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) การตั้งค่าเป็นโมฆะ())( lcd.begin(16, 2); // ตั้งค่าขนาดหน้าจอ lcd.createChar(1, smile); // สร้างหมายเลขตัวอักษร 1 lcd.setCursor(0, 0); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัด 1 lcd.print("\1"); // พิมพ์สไมลี่ (หมายเลขตัวอักษร 1) - "\1" ) void loop( ) ( )

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

ปัญหาที่จอแสดงผลอาจไม่ทำงาน

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

จอแอลซีดี LiquidCrystal_I2C (0x27,16,2);

ในวงเล็บ คุณจะเห็นค่าสองค่า 0x27 และ 16.2 (16.2 คือขนาดการแสดงผล และ 0x27 คือที่อยู่ I2C) แทนที่จะใช้ค่าเหล่านี้ คุณสามารถลองตั้งค่า 0x37 หรือ 0x3F อีกเหตุผลหนึ่งก็คือ LCD 1602 ที่ผิดปกติ เมื่อพิจารณาว่าเกือบทุกอย่างสำหรับ Arduino ผลิตในประเทศจีน คุณไม่สามารถมั่นใจได้ 100% ว่าผลิตภัณฑ์ที่ซื้อมาไม่มีข้อบกพร่อง

ข้อดีและข้อเสียของจอแอลซีดี 1602

มาดูข้อดีข้อเสียของจอแสดงผล LCD 1602 กัน

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

• ในระหว่างการใช้งานโดยนักวิทยุสมัครเล่นหลายพันคนไม่พบข้อเสียที่สำคัญมีเพียงกรณีการซื้อที่มีข้อบกพร่องเท่านั้นเนื่องจากส่วนใหญ่จะใช้จอแสดงผลเวอร์ชันภาษาจีน

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

ในบทความนี้ ฉันจะบอกวิธีใช้โมดูลอินเทอร์เฟซ I2C เพื่อควบคุมจอแสดงผล LCD (2x16 / 20x4) ด้วย โดยใช้อาดูโน่- โมดูลนี้ช่วยให้คุณลดจำนวนพินของคอนโทรลเลอร์ที่ใช้ แทนที่จะใช้การเชื่อมต่อแบบ 8 หรือ 4 บิต โดยต้องใช้เพียง 2 พินเท่านั้น (SDA และ SCL)

ข้อกำหนดทางเทคนิค

รองรับการแสดงผล: จอแอลซีดี 16×02 / 20×04
ทางเลือก: การปรับความคมชัด
แรงดันไฟฟ้า 5V
อินเทอร์เฟซ: I2C
ขนาด: 54มม.x 19มม.x 15มม

ข้อมูลทั่วไปเกี่ยวกับโมดูลอินเทอร์เฟซ I2C

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

ตอนนี้เล็กน้อยเกี่ยวกับโมดูลนั้นมันถูกสร้างขึ้นบนชิป PCF8574T ตัวต้านทาน R8 (4.7 kOhm) และ R9 (4.7 kOhm) จำเป็นสำหรับการดึงสาย SDA และ SCL ตามหลักการแล้ว เมื่อเชื่อมต่ออุปกรณ์สองตัวขึ้นไปผ่านบัส I2C คุณต้องใช้การดึงขึ้นบนอุปกรณ์เพียงเครื่องเดียว จะเขียนว่าทำไมในภายหลัง บนกระดานมีจัมเปอร์สามตัว (แผนภาพแสดงว่าสาย A0, A1, A2 เชื่อมต่อกับแหล่งจ่ายไฟผ่านตัวต้านทาน R4, R5, R6) ซึ่งจำเป็นต้องเปลี่ยนที่อยู่ของอุปกรณ์มีทั้งหมด 8 ตัวเลือก . การเปลี่ยนที่อยู่ทำให้เราสามารถเชื่อมต่ออุปกรณ์ได้สูงสุดแปดเครื่องผ่านบัส IC2 ด้วยชิป PCF8574T ตัวเลือกที่อยู่จะแสดงในรูป (ที่อยู่อุปกรณ์เริ่มต้นคือ 0x27) โมดูลนี้ยังมาพร้อมกับโพเทนชิออมิเตอร์ R11 ซึ่งช่วยให้คุณเปลี่ยนคอนทราสต์ของจอแสดงผล LCD ได้

มีผู้ติดต่อสามกลุ่มบนโมดูลสำหรับการเชื่อมต่อ:

กลุ่มแรก:
SCL: นาฬิกาอนุกรม
SDA: สายข้อมูล (Serial Dфta)
VCC: กำลัง "+"
GND: แหล่งจ่ายไฟ "-"

กลุ่มที่สอง:
VSS: พลัง "-"
VDD: กำลัง "+"
VO: พินควบคุมคอนทราสต์
RS: ลงทะเบียน เลือก
RW: อ่าน/เขียน (โหมดเขียนเมื่อเชื่อมต่อกับกราวด์)
E: เปิดใช้งาน (ตกแสงแฟลช)
DB0-DB3: อินเตอร์เฟสบิตต่ำ
DB4-DB7: อินเตอร์เฟสบิตสูง
A: "+" แหล่งจ่ายไฟแบ็คไลท์
K: "-" แหล่งจ่ายไฟแบ็คไลท์

กลุ่มที่สาม: (จัมเปอร์ตั้งค่าตามค่าเริ่มต้น)
วีซีซี:
A จากจอแอลซีดี:

การเชื่อมต่อกับ Arduino

ชิ้นส่วนที่จำเป็น:
Arduino UNO R3 x 1 ชิ้น
จอแสดงผล LCD 1602A (2×16, 5V, สีน้ำเงิน) x 1 ชิ้น
โมดูลอินเทอร์เฟซ I2C, IIC, TWI สำหรับ LCD x 1 ชิ้น
ลวดดูปองท์ 2.54 มม. 20 ซม. F-M (ตัวเมีย-ตัวผู้) x 1 ชิ้น
สายยูเอสบี 2.0 A-B x 1 ชิ้น

การเชื่อมต่อ:
ก่อนอื่น ประสานโมดูล I2C ไปที่ จอ LCDจากนั้นคุณจะต้องเชื่อมต่อจอแสดงผลกับ Arduino UNO ในการทำเช่นนี้เราจะใช้การเดินสายของดูปองท์โดยเชื่อมต่อตามตารางด้านล่าง

เพื่อความชัดเจนฉันจะให้แผนภาพอื่น

สำหรับการทดลองนี้ คุณต้องดาวน์โหลดและติดตั้งไลบรารี “LiquidCrystal_I2C” จากนั้นคัดลอกและวางโค้ดตัวอย่างนี้ลงในหน้าต่างโปรแกรม Arduino IDE แล้วโหลดลงในคอนโทรลเลอร์

/* ทดสอบบน Arduino IDE 1.6.11 วันที่ทดสอบ 15/9/2559 */ #รวม #รวม จอแอลซีดี LiquidCrystal_I2C (0x27,16,2); // ตั้งค่าที่อยู่และขนาดของการตั้งค่าโมฆะการแสดงผล() ( lcd.init(); // เริ่มต้น lcd lcd.backlight(); // เปิดแบ็คไลท์ lcd.setCursor(0,0); // ตั้งค่า เคอร์เซอร์ไปที่จุดเริ่มต้นของ 1 บรรทัด lcd .print("Hello, world"); // พิมพ์ข้อความ lcd.setCursor(0,1); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัด 2 lcd.print("www. site"); // พิมพ์ข้อความ ) void loop( ) ( )

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

ลิงค์
ดาวน์โหลดห้องสมุด
เอกสารประกอบสำหรับชิป
เอกสารสำหรับ

ซื้อใน Aliexpress