เราเชื่อมต่อจอ LCD หลักสูตรการฝึกอบรม การเชื่อมต่อ LCD เข้ากับไมโครคอนโทรลเลอร์ รับผลลัพธ์แรก แผนภาพการเชื่อมต่อของจอแสดงผล LCD กับ Arduino โดยใช้โปรโตคอล I2C

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

ขอจองด่วนครับจอเป็นสัญลักษณ์ ซึ่งหมายความว่าภายในความทรงจำของเขา เขามีตัวอักษรอยู่แล้ว สิ่งที่เราต้องทำก็แค่ออกคำสั่งให้พิมพ์บรรทัด

จอแสดงผลจะแตกต่างกัน: แสงพื้นหลังของหน้าจอมีสีต่างกัน, จำนวนบรรทัดต่างกัน, จำนวนอักขระต่อบรรทัดต่างกัน ดังนั้นที่นี่เราพิจารณาจอแสดงผล WH0802A-YGK-CT, 2 บรรทัด 8 ตัวอักษร, ไฟแบ็คไลท์ LED สีเหลือง

มาสร้างโปรเจ็กต์ใน CodeVision กันดีกว่า บนแท็บ LCD เราจะระบุพอร์ตที่จะเชื่อมต่อจอแสดงผลของเราจะเชื่อมต่อ (PORTD) ในบรรทัด Char/Line เราระบุจำนวนอักขระของจอ LCD ของเรา (8)

เราสร้างและบันทึกโครงการ เรานำโค้ดมาในรูปแบบต่อไปนี้:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#รวม #asm .equ __lcd_port= 0x12 ; PORTD #endasm #รวม เป็นโมฆะหลัก (เป็นโมฆะ) ( PORTD= 0x00 ; DDRD= 0x00 ; lcd_init(8 ) ; ในขณะที่ (1 ) ( ) ; )

#รวม #asm .equ __lcd_port=0x12 ;PORTD #endasm #include เป็นโมฆะหลัก (เป็นโมฆะ) ( PORTD=0x00; DDRD=0x00; lcd_init(8); ในขณะที่ (1) ( ); )

มาเปลี่ยนโค้ดโปรแกรมของเรากันหน่อย:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#รวม #asm .equ __lcd_port= 0x12 #endasm #include เป็นโมฆะหลัก(เป็นโมฆะ) ( PORTD= 0x00 ; DDRD= 0x00 ; lcd_init(8 ) ; lcd_gotoxy(0 , 0 ) ; lcd_putsf("lesson3" ) ; #pragma rl+ lcd_gotoxy(0 , 1 ) ; lcd_putsf("Lesson3" ) ; #pragma rl- ในขณะที่ (1 ) ( ) ; )

#รวม #asm .equ __lcd_port=0x12 #endasm #include เป็นโมฆะหลัก(เป็นโมฆะ) ( PORTD=0x00; DDRD=0x00; lcd_init(8); lcd_gotoxy(0,0); lcd_putsf("lesson3"); #pragma rl+ lcd_gotoxy(0,1); lcd_putsf("Lesson3"); #pragma rl- ในขณะที่ (1) ( ); )

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

ตอนนี้เราต้องลองดูทั้งหมดบนจอแสดงผลจริง มีความแตกต่างบางอย่างที่นี่ เราเปิดแผ่นข้อมูลบนจอแสดงผลของเราและดูตารางนี้พร้อม pinouts:

ทุกอย่างอาจชัดเจนที่นี่ แต่ยังคง:

1 - กราวด์ 0V

2 - แหล่งจ่ายไฟ +5V

3 - การควบคุมคอนทราสต์ เชื่อมต่อผ่านตัวต้านทานปรับค่าได้

ไฟ LED. เราเชื่อมต่อมันเหมือนกับ LED ทั่วไป

A - เชื่อมต่อกับ "+" ผ่านตัวต้านทานจำกัดกระแส K - เชื่อมต่อกับ "กราวด์" (GND)

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

ลักษณะที่ปรากฏของอุปกรณ์เฟิร์มแวร์

มีเฟิร์มแวร์และไฟล์ Proteus

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

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

• การเชื่อมต่อตัวบ่งชี้ LED มากกว่า 8 หลักเข้ากับไมโครคอนโทรลเลอร์เป็นเรื่องยากในทางปฏิบัติ ต้องใช้พินจำนวนมาก กระแสไฟบ่งชี้ที่สำคัญ สวิตช์ที่ซับซ้อน ความถี่การฟื้นฟูต่ำ ฯลฯ
• เป็นไปไม่ได้ที่จะแสดงข้อมูลเชิงสัญลักษณ์บนตัวบ่งชี้เจ็ดส่วน

หากต้องการแสดงข้อมูลข้อความหรือตัวเลขที่มีขนาดใหญ่กว่า 4 หลัก การใช้ตัวบ่งชี้ (จอแสดงผล) การสังเคราะห์อักขระคริสตัลเหลวจะเป็นประโยชน์มากกว่ามาก ข้อดี ได้แก่:

• อินเทอร์เฟซที่สะดวกสำหรับการเชื่อมต่อกับไมโครคอนโทรลเลอร์
• การใช้พลังงานต่ำ;
• แรงดันไฟฟ้าต่ำ
• ความทนทาน

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

ข้อมูลทั่วไป.

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

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

ในการควบคุมเมทริกซ์คริสตัลเหลวและจัดระเบียบอินเทอร์เฟซตัวบ่งชี้จะใช้คอนโทรลเลอร์ HD44780 ในตัวหรืออะนาล็อกแบบเต็ม คอนโทรลเลอร์นี้จะกำหนดสัญญาณอินเทอร์เฟซตัวบ่งชี้และคำสั่งควบคุม

HD44780 ได้กลายเป็นมาตรฐานที่แท้จริงสำหรับจอแสดงผลคริสตัลเหลว (LCD) สามารถดูเอกสารทางเทคนิคสำหรับคอนโทรลเลอร์ HD44780 ในรูปแบบ PDF ได้ที่ลิงค์นี้ - บางทีบางคนอาจชอบเอกสารของหนึ่งในอะนาล็อกของคอนโทรลเลอร์นี้ - SPLC780D ลิงค์ในรูปแบบ PDF - .

ไฟแสดงตัวอักษรแบบ LCD จาก Winstar

ฉันทราบตัวเลือกต่อไปนี้สำหรับตัวบ่งชี้ LCD จากบริษัทนี้

ประเภทตัวบ่งชี้	รูปแบบการแสดงผล ตัวอักษร x บรรทัด	ขนาด, มม	ขนาดพื้นที่มองเห็น mm	ลิงก์ไปยังเอกสารประกอบในรูปแบบ PDF
WH0802A1	8x2	58x32	38x16
WH1202A	12x2	55.7 x 32	46x14.5
WH1601A	16x1	80x36	66x16
WH1601B	16x1	85 x 28	66x16
WH1601L	16x1	122x33	99x13
WH1602A	16x2	84x44	66x16
WH1602B	16x2	80x36	66x16
WH1602C	16x2	80x36	66x16
WH1602D	16x2	85 x 30	66x16
WH1602J	16x2	80x36	66x16
WH1602L1	16x2	122x44	99x24
WH1602M	16x2	85x32.6	66x16
WH1602O	16x2	85 x 25.2	66x16
WH1602P	16x2	85 x 25.2	66x16
WH1602S	16x2	59x29.3	52x15
WH1602T	16x2	65.4 x 28.2	54.8 x 19
WH1602W	16x2	80x36	66x16
WH1602V2	16x2	66.7 x 23.3	61x15.9
WH1604A	16x4	87x60	62x26
WH1604B	16x4	70.6x60	60x32.6
WH2002A	20x2	116x37	85 x 18.6
WH2002D	20x2	89x21.5	75x15
WH2002L	20x2	180x40	149 x 23
WH2002M	20x2	146x43	123x23
WH2004A	20x4	98x60	77x25.2
WH2004B	20x4	98x60	77x25.2
WH2004D	20x4	77x47	60x22
WH2004G	20x4	87x58	74.4x24.8
WH2004H	20x4	87x58	74.4x24.8
WH2004L	20x4	146x62.5	123.5 x 43
WH2402A	24x2	118x36	94.5 x 16
WH4002A	40x2	182x33.5	154.4 x 16.5
WH4004A	40x4	190x54	147 x 29.5

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

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

โดยทั่วไปแล้ว ไฟแสดงสถานะ LCD จะมี 16 พิน

หมายเลขพิน	สัญญาณ	ฉัน - อินพุต O - เอาต์พุต	วัตถุประสงค์ของสัญญาณ
1	เทียบกับ	-	พื้น (ทั่วไป)
2	วดี	-	พาวเวอร์ซัพพลาย +5V
3	โว	-	แสดงการควบคุมคอนทราสต์ อินพุตสำหรับเชื่อมต่อเอาต์พุตกลางของตัวแบ่งแรงดันไฟฟ้า + 5 V คุณสามารถใช้ตัวต้านทานแบบทริมเมอร์ที่มีความต้านทาน 10-20 kOhm
4	อาร์.เอส.	ฉัน	การเลือกรีจิสเตอร์: 0 – การลงทะเบียนคำสั่ง; 1 – การลงทะเบียนข้อมูล ระดับสัญญาณต่ำหมายความว่ามีการสร้างคำสั่งบนบัสข้อมูล ระดับที่สูงหมายความว่ามีการสร้างคำสั่งบนบัสข้อมูล
5	ร/ดับบลิว	ฉัน	ทิศทางการถ่ายโอนข้อมูล: 0 – บันทึก; 1 – การอ่าน ในการใช้งานจำนวนมาก ฟังก์ชันการอ่านไม่ได้ใช้ ดังนั้นสัญญาณจึงมักเชื่อมต่อกับกราวด์
6	อี	ฉัน	ไฟแฟลชการทำงานของบัส (บนขอบลบ)
7	ดีบี0	ฉัน/โอ	บิตลำดับต่ำของโหมดแปดบิต ไม่ใช้กับอินเทอร์เฟซสี่บิต
8	ดีบี1	ฉัน/โอ
9	ดีบี2	ฉัน/โอ
10	ดีบี3	ฉัน/โอ
11	ดีบี4	ฉัน/โอ	บิตที่สำคัญที่สุดของโหมดแปดบิตหรือบิตข้อมูลของอินเทอร์เฟซสี่บิต
12	ดีบี5	ฉัน/โอ
13	ดีบี6	ฉัน/โอ
14	ดีบี7	ฉัน/โอ
15	ก	-	ขั้วบวกพลังงานแบ็คไลท์ (+)
16	เค	-	แคโทดไฟแบ็คไลท์ (-) กระแสต้องถูกจำกัด

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

จอแสดงผล LCD ตัวอักษรรองรับตัวเลือกการเชื่อมต่อกับไมโครคอนโทรลเลอร์สองตัวเลือก:

• การใช้บัสข้อมูล 8 บิต เชื่อมต่อสัญญาณบัสทั้งหมด DB0-DB7 แล้ว ในหนึ่งรอบการแลกเปลี่ยน ข้อมูลจำนวนหนึ่งจะถูกส่งไป
• การใช้บัสข้อมูล 4 บิต เชื่อมต่อเฉพาะ 4 บิตที่สำคัญที่สุด DB4-DB7 เท่านั้น ข้อมูลจะถูกส่งสี่บิตต่อรอบสัญญาณนาฬิกาของบัส

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

การเชื่อมต่อจอแสดงผล LCD ตัวอักษรเข้ากับบอร์ด Arduino

ฉันจะเชื่อมต่อตัวบ่งชี้ WH2004A (4 บรรทัดละ 20 ตัวอักษร) ในโหมดแลกเปลี่ยนสี่บิตกับบอร์ด Arduino UNO R3 คุณสามารถดูเอกสารประกอบสำหรับจอแสดงผล LCD WH2004 ได้ที่ลิงก์นี้

แผนภาพมีลักษณะเช่นนี้

ตัวต้านทาน R2 และ R3 กำหนดความคมชัดของตัวบ่งชี้ คุณสามารถเชื่อมต่อตัวต้านทานทริมและตั้งค่าความคมชัดของภาพที่ต้องการได้ ฉันมักจะใช้ตัวบ่งชี้ WH2004 และในวงจรของฉัน ฉันเลือกค่าตัวต้านทานเหล่านี้

ฉันเชื่อมต่อไฟ LED แบ็คไลท์ตัวบ่งชี้เข้ากับแหล่งพลังงาน 5 V ผ่านตัวต้านทาน R1 (30 โอห์ม) ด้วยเหตุนี้ฉันจึงตั้งค่ากระแสไว้ที่ประมาณ 25 mA มืดมนแต่เปล่งประกาย คุณสามารถมองเห็นได้ดีในความมืด แม้ว่าตัวบ่งชี้ WH2004 จะอนุญาตให้กระแสไฟแบ็คไลท์สูงถึง 580 mA

ไลบรารีสำหรับควบคุมตัวบ่งชี้ LCD ในระบบ Arduino LiquidCrystal

มีไลบรารีมาตรฐานสำหรับควบคุมตัวบ่งชี้ LCD โดยใช้คอนโทรลเลอร์ HD44780 ฉันจะอธิบายวิธีการของเธอโดยละเอียด

ลิควิดคริสตัล(…)

ตัวสร้างคลาส อาจมีจำนวนข้อโต้แย้งที่แตกต่างกัน

• LiquidCristal(rs, en, d4, d5, d6, d7) – อินเทอร์เฟซสี่บิต ไม่ได้ใช้สัญญาณ RW (เชื่อมต่อกับกราวด์)
• LiquidCristal(rs,rw, en, d4, d5, d6, d7) – อินเทอร์เฟซสี่บิต ใช้สัญญาณ RW
• LiquidCristal(rs, en, d0, d1, d2, d3, d4, d5, d6, d7) – อินเทอร์เฟซ 8 บิต ไม่ได้ใช้สัญญาณ RW (เชื่อมต่อกับกราวด์)
• LiquidCristal(rs, rw, en, d0, d1, d2, d3, d4, d5, d6, d7) – อินเทอร์เฟซ 8 บิต, ใช้สัญญาณ RW

ข้อโต้แย้ง:

• rs – หมายเลขพินสัญญาณ RS;
• rw – หมายเลขเอาต์พุตสัญญาณ RW;
• en – หมายเลขเอาต์พุตสัญญาณ E;
• d0, d1, d2, d3, d4, d5, d6, d7 – หมายเลขพินบัสข้อมูล

เครื่องจ่ายของเหลวคริสตัล (6, 7, 2, 3, 4, 5);

เป็นโมฆะเริ่มต้น (คอลัมน์, แถว)

เริ่มต้นอินเทอร์เฟซตัวบ่งชี้ ตั้งค่ามิติตัวบ่งชี้ ต้องเรียกเมธอดนี้ก่อน ก่อนที่จะใช้ฟังก์ชันคลาสอื่น

ข้อโต้แย้ง:

• cols – จำนวนอักขระในบรรทัด;
• แถว – จำนวนแถว

disp.begin(20, 4); // เราใช้จอแสดงผล - 4 บรรทัด 20 ตัวอักษร

เป็นโมฆะชัดเจน()

การเคลียร์หน้าจอโดยวางเคอร์เซอร์ไว้ที่มุมซ้ายบน

disp.ชัดเจน(); //รีเซ็ตการแสดงผล

บ้านเป็นโมฆะ()

วางเคอร์เซอร์ไว้ที่มุมซ้ายบน

disp.home(); // ไปที่จุดเริ่มต้นของหน้าจอ

เป็นโมฆะ setCursor (คอลัมน์, แถว)

วางเคอร์เซอร์ไว้ที่ตำแหน่งที่ระบุ

• col – พิกัด X นับจาก 0;
• แถว – พิกัด Y นับจาก 0

ตั้งเคอร์เซอร์(0,1); // เคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดที่สอง

ไบต์เขียน (ข้อมูล)

แสดงสัญลักษณ์บนหน้าจอ ส่งกลับจำนวนไบต์ที่ถ่ายโอน

ภาพร่างต่อไปนี้แสดงข้อมูลจากพอร์ตอนุกรม ข้อมูลสามารถส่งผ่านจอภาพพอร์ต Arduino IDE

// เอาต์พุตข้อมูลพอร์ตอนุกรมบนตัวบ่งชี้ LCD
#รวม


ข้อมูลถ่าน

การตั้งค่าเป็นโมฆะ ()
{
อนุกรมเริ่มต้น(9600); // เริ่มต้นพอร์ตอนุกรม
disp.begin(20, 4); //
}

เป็นโมฆะวน()
{
ถ้า (Serial.available()) ( // หากมีข้อมูล
ข้อมูล = Serial.read (); // อ่านสัญลักษณ์
if((data != 0xd) && (data != 0xa)) ( // ป้อนบรรทัด
disp.write (ข้อมูล); // แสดงสัญลักษณ์บนหน้าจอ
}
}
}

ฉันมีตัวบ่งชี้ขนาดใหญ่ - 4 บรรทัด 20 ตัวอักษร ประกอบด้วยคอนโทรลเลอร์ HD44780 สองตัว ดังนั้นอักขระที่ส่งตามลำดับจะเติมบรรทัดแรกก่อน จากนั้นบรรทัดที่สาม จากนั้นบรรทัดที่สองและสี่ เหล่านั้น. ผ่านเส้น ต้องคำนึงถึงคุณสมบัตินี้สำหรับตัวบ่งชี้บางประเภท เอกสารประกอบสำหรับตัวบ่งชี้ LCD แต่ละตัวจะระบุลำดับการกำหนดที่อยู่อักขระ

การพิมพ์ไบต์ (ข้อมูล)

แสดงข้อความบนหน้าจอ ส่งกลับจำนวนไบต์ที่ถ่ายโอน

ฟังก์ชันนี้มีรูปแบบการโทรที่แตกต่างกันสำหรับรูปแบบและประเภทข้อมูลที่แตกต่างกัน

พิมพ์ (ถ่าน d)	หากอาร์กิวเมนต์ถ่านส่งออกโค้ดอักขระ ถ่าน d= 83; disp.พิมพ์(d); // พิมพ์อักขระ S disp.print('S'); // พิมพ์อักขระ S
พิมพ์(int d)	หากอาร์กิวเมนต์เป็นประเภทจำนวนเต็ม ให้พิมพ์สตริงที่มีการแสดงตัวเลขในรูปแบบทศนิยม อินท์ d= 83; disp.พิมพ์(d); // พิมพ์บรรทัด “83” disp พิมพ์ (83); // พิมพ์บรรทัด “83”
พิมพ์ (ลอย)	ประเภทจริงจะถูกส่งออกเป็นอักขระ ASCII ซึ่งเป็นทศนิยมสองตำแหน่ง ลอย d= 7.65432; disp.พิมพ์(d); // พิมพ์สตริง “7.65” disp พิมพ์ (7.65432); // พิมพ์สตริง “7.65”
พิมพ์(*str)	หากอาร์กิวเมนต์เป็นตัวชี้ไปยังสตริง สตริงข้อความจะถูกพิมพ์ ตัวอักษรถ่าน= (65, 66, 67); disp.print("ตัวอักษร"); // พิมพ์สตริง “ตัวอักษร” disp.พิมพ์(ตัวอักษร); // ส่งออกสตริงอักขระ 3 ตัวพร้อมรหัส 65, 66, 67
พิมพ์(int d, ธ.ค.)	พิมพ์สตริง ASCII - การแสดงตัวเลขทศนิยม อินท์ d= 83; disp.print(ง, ธ.ค.); // ส่งออกสตริง “83”
พิมพ์(int d, HEX)	เอาต์พุตสตริง ASCII - การแสดงตัวเลขฐานสิบหก อินท์ d= 83; disp.print(d, HEX); // ส่งออกบรรทัด “53”
พิมพ์(int d, ต.ค.)	พิมพ์สตริง ASCII - การแสดงตัวเลขฐานแปด อินท์ d= 83; disp.print(ง, ต.ค.); // ส่งออกสตริง “123”
พิมพ์(int d, BIN)	ส่งออกสตริง ASCII - การแสดงไบนารีของตัวเลข อินท์ d= 83; disp.print(d, BIN); // ส่งออกสตริง “01010011”
พิมพ์(ลอย d, N)	สำหรับจำนวนจริง พารามิเตอร์ N ระบุจำนวนหลักหลังจุดทศนิยม disp พิมพ์ (7.65432, 0); // พิมพ์สตริง “7” disp พิมพ์ (7.65432, 2); // พิมพ์สตริง “7.65” disp.พิมพ์(7.65432, 4); // ส่งออกสตริง “7.6543”

ตัวอย่างโปรแกรมที่พิมพ์สตริงข้อความบนจอแสดงผล

// การแสดงบรรทัดข้อความบนตัวแสดงสถานะ LCD
#รวม

เครื่องจ่ายของเหลวคริสตัล (6, 7, 2, 3, 4, 5); // สร้างวัตถุ

การตั้งค่าเป็นโมฆะ ()
{
disp.begin(20, 4); // เริ่มต้นการแสดงผล 4 บรรทัด 20 ตัวอักษร
disp.print("ทดสอบสตริง");
}

เป็นโมฆะวน()
{ }

เคอร์เซอร์เป็นโมฆะ ()

เปิดใช้งานโหมดการแสดงเคอร์เซอร์ ตำแหน่งที่อักขระถัดไปจะถูกส่งออกจะถูกขีดเส้นใต้

disp.เคอร์เซอร์(); // อนุญาตให้แสดงเคอร์เซอร์

เป็นโมฆะไม่มีเคอร์เซอร์ ()

ปิดใช้งานการแสดงเคอร์เซอร์

disp.noCursor(); // ปิดการใช้งานการแสดงเคอร์เซอร์

โมฆะกะพริบ ()

เปิดใช้งานโหมดเคอร์เซอร์กะพริบ ใช้ร่วมกับฟังก์ชันเคอร์เซอร์ () ผลลัพธ์ขึ้นอยู่กับรุ่นตัวบ่งชี้เฉพาะ

disp.กะพริบ(); // อนุญาตให้เคอร์เซอร์กะพริบ

เป็นโมฆะ noBlink()

ปิดใช้งานโหมดเคอร์เซอร์กะพริบ

disp.noBlink(); // ปิดการใช้งานเคอร์เซอร์กะพริบ

จอแสดงผลเป็นโมฆะ ()

เปิดหน้าจอหลังจากที่ปิดโดย noDisplay() หน้าจอจะแสดงข้อมูลที่มีอยู่ก่อนปิดเครื่อง

display.display(); // เปิดจอแสดงผล

เป็นโมฆะ noDisplay ()

ปิดหน้าจอ ข้อมูลจะถูกเก็บไว้ในหน่วยความจำและจะปรากฏขึ้นเมื่อเปิดจอแสดงผล

disp.noDisplay(); // ปิดหน้าจอ

โมฆะ scrollDisplayLeft()

เลื่อนเนื้อหาที่แสดงไปทางซ้ายหนึ่งอักขระ

แสดง scrollDisplayLeft(); // ย้ายทุกอย่างไปทางซ้าย

โมฆะ scrollDisplayRight()

เลื่อนเนื้อหาที่แสดงไปทางขวาหนึ่งอักขระ

แสดง scrollDisplayRight(); // ย้ายทุกอย่างไปทางขวา

เป็นโมฆะการเลื่อนอัตโนมัติ ()

เปิดใช้งานโหมดเลื่อนข้อความอัตโนมัติ ขณะที่อักขระแต่ละตัวแสดงขึ้น ข้อความทั้งหมดบนหน้าจอจะเลื่อนไปหนึ่งอักขระ ฟังก์ชัน leftToRight() และ rightToLeft() จะกำหนดทิศทางที่ข้อมูลจะถูกเลื่อน

แสดง เลื่อนอัตโนมัติ())(; // เปิดใช้งานการเลื่อนอัตโนมัติ

เป็นโมฆะ noAutoscroll()

ปิดการเลื่อนข้อความอัตโนมัติ

แสดง noAutoscroll())(; // ปิดการใช้งานการเลื่อนอัตโนมัติ

เป็นโมฆะ leftToRight()

ตั้งค่าโหมดเอาต์พุตทดสอบจากซ้ายไปขวา สัญลักษณ์ใหม่จะปรากฏทางด้านขวาของสัญลักษณ์ก่อนหน้า

ซ้ายไปขวา(); // โหมดซ้ายไปขวา

เป็นโมฆะ rightToLeft()

ตั้งค่าโหมดเอาต์พุตทดสอบจากขวาไปซ้าย สัญลักษณ์ใหม่จะปรากฏทางด้านซ้ายของสัญลักษณ์ก่อนหน้า

จากขวาไปซ้าย(); // โหมดขวาไปซ้าย

เป็นโมฆะ createChar (หมายเลขข้อมูล)

วิธีการสร้างสัญลักษณ์ที่กำหนดเอง คอนโทรลเลอร์อนุญาตให้สร้างอักขระขนาด 5x8 พิกเซลได้สูงสุด 8 ตัว (0...7) ภาพสัญลักษณ์ถูกระบุโดยอาร์เรย์ 8 ไบต์ 5 บิตที่มีนัยสำคัญน้อยที่สุดของแต่ละไบต์จะกำหนดสถานะของพิกเซลในแถว

หากต้องการส่งออกอักขระที่กำหนดเอง คุณสามารถใช้ฟังก์ชัน write() พร้อมหมายเลขอักขระได้

// การสร้างสัญลักษณ์ที่กำหนดเอง
#รวม

เครื่องจ่ายของเหลวคริสตัล (6, 7, 2, 3, 4, 5); // สร้างวัตถุ

ไบต์ยิ้ม = (
B00000000,
B00010001,
B00000000,
B00000000,
B00010001,
B00001110,
B00000000,
บี00000000
};

การตั้งค่าเป็นโมฆะ ()
{
disp.createChar (0, ยิ้ม); // สร้างสัญลักษณ์
disp.begin(20, 4); // เริ่มต้นการแสดงผล 4 บรรทัด 20 ตัวอักษร
disp.print("ยิ้ม");
disp.write(ไบต์(0)); // พิมพ์สัญลักษณ์
}

เป็นโมฆะวน()
{ }

นี่คือตัวอย่างโปรแกรมที่แสดงตัวอักษรรัสเซีย

// เอาต์พุตตัวอักษรรัสเซีย
#รวม

LiquidCrystalRus แสดงผล (6, 7, 2, 3, 4, 5); // สร้างวัตถุ

การตั้งค่าเป็นโมฆะ ()
{
disp.begin(20, 4); // เริ่มต้นการแสดงผล 4 บรรทัด 20 ตัวอักษร
disp.print("abvgdeezhziyklmnoprst");
disp.print("ABVGDEYOZHIYKLMNOPRST");
disp.print("อ๊ากๆๆๆๆๆๆๆๆ");
disp.print("UFHTSCHSHSHSHYYYYYYYYYYYYYYYYYYYYYYY");
}

เป็นโมฆะวน()
{ }

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

ก่อนอื่นฉันจะทำการจองทันทีที่เราจะพูดถึง จอแอลซีดีตัวบ่งชี้บนตัวควบคุม HD44780,ซึ่งได้กลายเป็นมาตรฐานอุตสาหกรรมโดยพฤตินัยในตลาดจอแสดงผลแบบตัวอักษรและตัวเลข ขายทุกที่ที่เป็นไปได้มีราคาไม่แพง (8x2 เสียค่าใช้จ่ายประมาณ 150 รูเบิล) และยังมีโค้ดที่เขียนไว้มากมายอีกด้วย ตามปกติแล้ว ฉันตัดสินใจที่จะคิดค้นวงล้อใหม่และสร้างห้องสมุดของตัวเองสำหรับการทำงานกับตัวบ่งชี้ประเภทนี้ แน่นอนในแอสเซมเบลอร์ แต่มีอะไรอีกล่ะ? ;)

การเชื่อมต่อ.
จอแอลซีดีบนฐาน HD44780เชื่อมต่อกับ เอวีอาร์ไมโครคอนโทรลเลอร์ไปยังพอร์ตโดยตรง มีวิธีการเชื่อมต่อสองวิธี - 8 บิตและ 4 บิต ในโหมดแปดบิต การอัปโหลดไบต์จะง่ายกว่าเล็กน้อย คุณไม่จำเป็นต้องเปลี่ยนไบต์ แต่ในโหมดสี่บิต คุณจะต้องใช้ขาควบคุมน้อยลงถึงสี่ขา มีอีกหนึ่งคุณสมบัติในการทำงานในโหมด 8 บิต - จอแสดงผลนี้สามารถเชื่อมต่อกับคอนโทรลเลอร์บางตัวได้ เป็น RAM ภายนอกและส่งข้อมูลโดยใช้คำสั่งการส่งต่ออย่างง่าย โดยส่วนตัวแล้วฉันเชื่อมต่อมันในโหมดพอร์ตเต็มฉันไม่มีที่จะวางเทอร์มินัลอันใดอันหนึ่งดังนั้นจึงไม่น่าเสียดาย

• ข้อสรุป DB7…DB0นี่คือบัสข้อมูล/ที่อยู่
• อี- อินพุตแฟลช โดยการกระตุกแรงดันไฟฟ้าบนสายนี้ เราจะแจ้งให้จอแสดงผลทราบว่าจำเป็นต้องรับ/ส่งข้อมูลจาก/ไปยังบัสข้อมูล
• รว— กำหนดทิศทางที่ข้อมูลของเรากำลังเคลื่อนที่ ถ้าเป็น 1 ให้อ่านจากจอแสดงผล ถ้าเป็น 0 ให้เขียนไปที่จอแสดงผล
• อาร์.เอส.— กำหนดสิ่งที่กำลังส่ง คำสั่ง (RS=0) หรือข้อมูล (RS=1) ข้อมูลจะถูกเขียนลงในหน่วยความจำตามที่อยู่ปัจจุบัน และตัวควบคุมจะดำเนินการคำสั่ง

ในด้านพลัง สิ่งต่างๆ จะง่ายขึ้นไปอีก:

• จีเอ็นดี- ลบมันเป็นเรื่องธรรมดา
• วีซีซี- บวกแหล่งจ่ายไฟปกติ 5V
• V0— อินพุตคอนทราสต์ ที่นี่คุณจะต้องใช้แรงดันไฟฟ้าจากศูนย์ถึงแรงดันไฟฟ้าซึ่งจะเป็นการตั้งค่าความคมชัดของภาพ คุณสามารถติดตั้งตัวต้านทานแบบปรับค่าได้ที่เปิดโดยโพเทนชิออมิเตอร์แล้วบิดให้ได้ตามใจคุณ สิ่งสำคัญคือการจับค่าคอนทราสต์สูงสุด แต่เพื่อไม่ให้มองเห็นความคุ้นเคย (รัศมีสีเทาของสี่เหลี่ยมรอบๆ สัญลักษณ์) หากคุณตั้งค่าคอนทราสต์ต่ำเกินไป ตัวละครจะเปลี่ยนอย่างเกียจคร้านและรอบคอบ เหมือนเครื่องคิดเลขที่แบตหมด
• ก— นี่คืออินพุตของแอโนดแบ็คไลท์ LED ในระยะสั้นบวก
• ถึง- ดังนั้น แคโทดหรือที่เรียกว่าลบ ไฟแบ็คไลท์ดึงพลังงานประมาณ 100mA ดังนั้นคุณต้องติดตั้งตัวต้านทานจำกัดกระแส 100 โอห์มที่นั่น อย่างไรก็ตาม จอ LCD จำนวนมากมีจุดบนบอร์ดสำหรับบัดกรีตัวต้านทาน หากคุณโทร คุณสามารถตรวจสอบให้แน่ใจว่าเส้นเหล่านี้นำไปสู่อินพุตไฟของ LCD ดังนั้นโดยการบัดกรีตัวต้านทาน คุณจะไม่ต้องกังวลกับการจ่ายไฟแบ็คไลท์ เพราะมันจะเชื่อมต่อกับแหล่งจ่ายไฟของคอนโทรลเลอร์

โครงสร้างทางตรรกะของคอนโทรลเลอร์ LCD HD44780

คอนโทรลเลอร์มีหน่วยควบคุมของตัวเองซึ่งประมวลผลคำสั่งและหน่วยความจำ แบ่งออกเป็นสามประเภท:

แรม- แสดงหน่วยความจำ ทุกสิ่งที่บันทึกไว้ใน แรมจะแสดงบนหน้าจอ ตัวอย่างเช่นเราเขียนโค้ดที่นั่น 0x31- จะมีสัญลักษณ์ปรากฏขึ้นบนหน้าจอ "1"เพราะ 0x31นี่คือรหัส ASCII ของตัวเลข 1. แต่มีลักษณะเฉพาะอย่างหนึ่งที่นี่ - แรมหน่วยความจำมีขนาดใหญ่กว่าพื้นที่ที่มองเห็นได้ของหน้าจอมาก โดยปกติ, แรมประกอบด้วย 80 เซลล์- 40 ในบรรทัดแรกและ 40 ในบรรทัดที่สอง และจอแสดงผลสามารถเลื่อนไปตามบรรทัดนี้เหมือนกับหน้าต่างบนกฎสไลด์ โดยเน้นพื้นที่ที่มองเห็นได้ นั่นคือคุณสามารถใส่มันลงไปได้ แรมห้ารายการเมนูพร้อมกัน จากนั้นเพียงเลื่อนหน้าจอไปมาโดยแสดงรายการทีละรายการ มีคำสั่งพิเศษให้เลื่อนจอภาพ นอกจากนี้ยังมีแนวคิดของเคอร์เซอร์ - นี่คือตำแหน่งที่จะเขียนอักขระตัวถัดไปเช่น มูลค่าปัจจุบันของตัวนับที่อยู่ เคอร์เซอร์ไม่จำเป็นต้องอยู่บนหน้าจอ สามารถอยู่ด้านหลังหน้าจอหรือปิดใช้งานไปเลยก็ได้

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

ซีแกรม- ยังเป็นตารางสัญลักษณ์ แต่เราสามารถเปลี่ยนได้โดยการสร้างสัญลักษณ์ของเราเอง ได้รับการแก้ไขเป็นเส้นตรง นั่นคือ อันดับแรกมีอักขระหนึ่งตัวขนาด 8 ไบต์ ทีละบรรทัด จากล่างขึ้นบน - หนึ่งบิตเท่ากับหนึ่งจุดบนหน้าจอ จากนั้นสัญลักษณ์ที่สองในลักษณะเดียวกัน เนื่องจากความคุ้นเคยของเราคือ 5 คูณ 8 แต้มแล้ว สามบิตที่สำคัญที่สุดไม่สำคัญ. รวมเข้า ซีแกรมสามารถมีได้ 8 ตัวอักษรตามลำดับ ซีแกรมมันมี 64 ไบต์ของหน่วยความจำ อักขระที่ตั้งโปรแกรมได้เหล่านี้มีรหัสตั้งแต่ 0x00 ถึง 0x07 เช่นการโยนในครั้งแรกเป็นต้น 8 ไบต์ ซีแกรม(อักขระตัวแรกที่มีรหัส 00) ขยะบางชนิดและเขียนลงไป แรมศูนย์ (รหัสของอักขระตัวแรกใน ซีแกรม) เราจะเห็นอึของเราบนหน้าจอ

การเข้าถึงหน่วยความจำ
ทุกอย่างเรียบง่ายที่นี่ เราใช้คำสั่งเพื่อเลือกหน่วยความจำและเริ่มจากที่อยู่ที่เราจะเขียน จากนั้นเพียงแค่ส่งไบต์ หากระบุว่าเรากำลังเขียนถึง DDRAM อักขระจะปรากฏบนหน้าจอ (หรือในพื้นที่ที่ซ่อนอยู่) หากเป็น CGRAM ไบต์จะปรากฏในหน่วยความจำตัวสร้างอักขระแล้ว สิ่งสำคัญคืออย่าลืมเปลี่ยนกลับเข้าพื้นที่ แรม

ระบบสั่งการ.
ระบบคำสั่งนั้นง่ายเหมือนหมู่ ขาจะระบุว่าคำสั่งกำลังถูกส่งไปยังตัวควบคุมการแสดงผล อาร์.เอส.=0. คำสั่งนั้นประกอบด้วยบิตที่สำคัญที่สุดซึ่งกำหนดว่าคำสั่งนี้รับผิดชอบอะไร และบิตพารามิเตอร์ซึ่งบอกคอนโทรลเลอร์ HD44780 ว่าต้องดำเนินการอย่างไร

ตารางคำสั่ง:

ดีบี7	ดีบี6	ดีบี5	ดีบี4	ดีบี3	ดีบี2	ดีบี1	ดีบี0	ความหมาย
0	0	0	0	0	0	0	1	การทำความสะอาดหน้าจอ ที่อยู่ตัวนับที่ตำแหน่ง 0 ของ DDRAM
0	0	0	0	0	0	1	—	ระบุถึงกะการรีเซ็ต DDRAM ที่อยู่ตัวนับเป็น 0
0	0	0	0	0	1	ฉัน/ดี	ส	หน้าจอการตั้งค่าและการเลื่อนเคอร์เซอร์
0	0	0	0	1	ดี	ค	บี	การตั้งค่าโหมดการแสดงผล
0	0	0	1	เอส/ซี	ซ้าย/ขวา	—	—	เลื่อนเคอร์เซอร์หรือหน้าจอ ขึ้นอยู่กับบิต
0	0	1	ดี.แอล.	เอ็น	เอฟ	—	—	การเลือกจำนวนบรรทัด ความกว้างบัส และขนาดตัวอักษร
0	1	เอ.จี.	เอ.จี.	เอ.จี.	เอ.จี.	เอ.จี.	เอ.จี.	สลับที่อยู่เป็น SGRAM และตั้งค่าที่อยู่ใน SGRAM
1	ค.ศ	ค.ศ	ค.ศ	ค.ศ	ค.ศ	ค.ศ	ค.ศ	สลับที่อยู่เป็น DDRAM และตั้งค่าที่อยู่เป็น DDRAM

ตอนนี้ฉันจะอธิบายว่าแต่ละบิตหมายถึงอะไร:

• ฉัน/ดี— เพิ่มหรือลดตัวนับที่อยู่ ค่าเริ่มต้นคือ 0 - การลดลง เหล่านั้น. แต่ละไบต์ต่อมาจะถูกเขียนลงในเซลล์ n-1 หากใส่ 1 จะมีการเพิ่มขึ้น
• ส— การเปลี่ยนหน้าจอหากคุณตั้งค่าเป็น 1 จากนั้นหน้าต่างหน้าจอจะเปลี่ยนอักขระใหม่แต่ละตัวจนกว่าจะถึงจุดสิ้นสุดของ DDRAM มันอาจจะสะดวกเมื่อคุณแสดงบรรทัดที่หนักหน่วงบนหน้าจอสำหรับอักขระทั้งหมด 40 ตัว เพื่อไม่ให้หลุดออกจากหน้าจอ
• ดี— เปิดจอแสดงผล หากคุณใส่ 0 ตรงนั้น รูปภาพจะหายไป และในเวลานี้ เราสามารถทำสิ่งลามกอนาจารได้ทุกประเภทในหน่วยความจำวิดีโอ และจะไม่ทำให้ปวดตา และเพื่อให้รูปภาพปรากฏในตำแหน่งนี้ คุณต้องเขียน 1
• กับ— เปิดเคอร์เซอร์ในรูปแบบของเส้นประ ง่ายมาก เขียน 1 ที่นี่ - เคอร์เซอร์จะเปิดขึ้น
• บี— ทำให้เคอร์เซอร์ดูเหมือนสี่เหลี่ยมสีดำกะพริบ
• เอส/ซีการเลื่อนเคอร์เซอร์หรือหน้าจอ ถ้าเป็น 0 เคอร์เซอร์จะเคลื่อนที่ ถ้า 1 ให้สกรีน หนึ่งครั้งต่อทีม
• ซ้าย/ขวา— กำหนดทิศทางการเลื่อนเคอร์เซอร์และหน้าจอ 0 - ซ้าย 1 - ขวา
• ส/ล— บิตที่กำหนดความกว้างของบัสข้อมูล 1-8 บิต, 0-4 บิต
• เอ็น— จำนวนบรรทัด 0 - หนึ่งบรรทัด, 1 - สองบรรทัด
• เอฟ— สัญลักษณ์ขนาด 0 — 5x8 พิกเซล 1 - 5x10 แต้ม (หายากมาก)
• เอ.จี.- ที่อยู่ในหน่วยความจำ ซีแกรม
• ค.ศ- ที่อยู่ในหน่วยความจำ แรม

ตัวฉันเองจ้องมองที่ป้ายนี้เป็นเวลานานโดยพยายามเข้าใจว่าพวกเขาต้องการอะไรจากฉัน เห็นได้ชัดว่าเขาอดนอน แต่จริงๆ แล้ว มันไม่ชัดเจนตั้งแต่แรกเห็น ดังนั้นฉันจะยกตัวอย่างมาสนับสนุน

งาน:

1. เปิดจอแสดงผล
2. ล้างเนื้อหา
3. เลื่อนเคอร์เซอร์หนึ่งตำแหน่ง
4. และเขียน “1” ตรงนั้น

โซลูชัน (ลำดับของคำสั่ง):

สิ่งแรก การเริ่มต้นจอแสดงผลที่ไม่มีจอแสดงผลส่วนใหญ่บน HD44780 จะปฏิเสธที่จะทำงาน บางชนิดมีสถานะเริ่มต้น (บัส 8 บิต เคอร์เซอร์ที่ 0) และจำเป็นต้องเปิดจอแสดงผลเท่านั้น แต่ก็ยังดีกว่าถ้าทำ คุณไม่มีทางรู้ว่านักพัฒนาทำอะไรไว้บ้าง จะไม่มีอะไรพิเศษ

1. 001 11000 บัส 8 บิต 2 เส้น
2. 00000001 การทำความสะอาดหน้าจอ
3. 000001 10 ที่อยู่ที่เพิ่มขึ้น หน้าจอไม่ขยับ

1. 00001 100 เปิดจอแสดงผล (D=1)
2. 00000001 ล้างจอแสดงผลแล้ว ตัวชี้อยู่ที่ DDRAM
3. 0001 0100 เลื่อนเคอร์เซอร์ (S/C=0) ไปทางขวา (R/L=1)
4. 00110001 - เราได้บันทึกข้อมูลแล้ว (RS pin = 1) รหัส “1” 0x31

ตัวระบุทีมจะถูกเน้นด้วยตัวหนา แต่คุณจะเห็นส่วนที่เหลือในตาราง

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

สารละลาย:

1. 01 001000 เลือกเข้า ซีแกรมที่อยู่ 0x08 เป็นเพียงจุดเริ่มต้นของอักขระตัวที่สอง (ฉันขอเตือนคุณว่าอักขระหนึ่งตัวใช้เวลา 8 ไบต์)
2. 00000001 นี่คือข้อมูลขนาด 8 ไบต์ ( อาร์เอส=1)
3. 0000001 0 วาดไอคอนรูปสายฟ้า หรือ
4. 000001 00 SS Zig rune ตามที่คุณต้องการ
5. 00001 ผมชอบ 000 มากกว่า
6. 00011111 สามบิตที่สำคัญที่สุดไม่มีผลใดๆ
7. 0000001 0 คุณสามารถเขียนอะไรก็ได้ที่นั่น
8. 000001 00 จะไม่ส่งผลต่อผลลัพธ์
9. 00001 000 ไบต์สุดท้ายของข้อมูล
10. 1 0000000 และนี่คือคำสั่ง - สลับที่อยู่เป็น แรมและตัวชี้ไปยังที่อยู่ 0000000 — อักขระตัวแรกในบรรทัดแรก
11. 00000001 และข้อมูลอีกครั้ง ( อาร์เอส=1) รหัส 01 - นี่คือที่ที่เราใส่ซิป

อ๊ะ เขาอยู่บนหน้าจอแล้ว!

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

อัลกอริทึมสำหรับการอ่าน/เขียนไปยังคอนโทรลเลอร์ LCD HD44780
ทิศทางตลอดจนคำสั่ง/ข้อมูลถูกกำหนดโดยขา และการอ่านและการเขียนจะดำเนินการโดยการเปลี่ยนแฟลช (พิน E) จาก 1 เป็น 0

กำลังเตรียมใช้งานพอร์ต

1. RS, RW, E - เพื่อออกจากโหมด
2. DB7..DB0 เข้าสู่โหมดอินพุต อย่างไรก็ตาม คุณไม่จำเป็นต้องแตะต้องสิ่งเหล่านั้น เราจะกำหนดใหม่ในภายหลัง

รอความพร้อมอ่านธงยุ่ง

1. RS=0 (คำสั่ง)
2. RW=1 (อ่าน)
3. E=1 (เตรียมตัวให้พร้อม!!!)
4. หยุดชั่วคราว (รอบโปรเซสเซอร์ 14 รอบที่ 8 MHz ก็เพียงพอแล้ว)
5. E=0 (พลี!)
6. อ่านจากท่าเรือ หากตั้งค่าบิต 7 (แฟล็กไม่ว่าง) เราจะทำซ้ำทุกอย่างอีกครั้งจนกว่าจะรีเซ็ต

เขียนคำสั่ง

1. รอความพร้อม.
2. RS=0 (คำสั่ง)
3. RW=0 (เขียน)
4. E=1 (เตรียมตัวให้พร้อม!!!)
5. พอร์ตเอาท์พุต
6. ส่งออกรหัสคำสั่งไปยังพอร์ต
7. หยุดชั่วคราว
8. E=0 (พลี!)
9. ท่าปืนไหล่สำหรับเข้า เผื่อไว้

การบันทึกข้อมูล

1. รอความพร้อม.
2. RS=1 (ข้อมูล)
3. RW=0 (เขียน)
4. E=1 (เตรียมตัวให้พร้อม!!!)
5. พอร์ตเอาท์พุต
6. ส่งออกรหัสคำสั่งไปยังพอร์ต
7. หยุดชั่วคราว
8. E=0 (พลี!)
9. พอร์ตสำหรับเข้า เผื่อไว้

อ่านคำสั่ง

1. รอความพร้อม.
2. พอร์ตข้อมูลสำหรับอินพุตแบบดึงขึ้น (DDR=0, PORT=1)
3. RS=0 (คำสั่ง)
4. RW=1 (อ่าน)
5. หยุดชั่วคราว
6. อ่านข้อมูลจากพอร์ต
7. E=0 (ที่!)

อ่านข้อมูล

1. รอความพร้อม.
2. พอร์ตข้อมูลสำหรับอินพุตแบบดึงขึ้น (DDR=0, PORT=1)
3. RS=1 (ข้อมูล)
4. RW=1 (อ่าน)
5. E = 1 (เตรียมตัวให้พร้อม! ขณะนี้ข้อมูลจาก LCD กำลังถูกส่งไปยังบัส)
6. หยุดชั่วคราว
7. อ่านข้อมูลจากพอร์ต
8. E=0 (ที่!)

ด้วยบัสสี่บิต ทุกอย่างจะเหมือนกันทุกประการ เฉพาะการดำเนินการอ่าน/เขียนแต่ละครั้งเท่านั้นที่จะเสร็จสิ้นด้วยการดึงแฟลชสองครั้ง

รายการ:

1. หยุดชั่วคราว
2. พวกเขาวางโน้ตบุ๊กรุ่นพี่ไว้ในพอร์ต
3. หยุดชั่วคราว
4. หยุดชั่วคราว
5. จูเนียร์ tetrad ถูกนำตัวไปที่ท่าเรือ

การอ่าน

1. หยุดชั่วคราว
2. กำลังอ่านสมุดบันทึกรุ่นพี่จากท่าเรือ
3. หยุดชั่วคราว
4. หยุดชั่วคราว
5. อ่านค่าเตตราดต่ำจากท่าเรือ

รอรับโค้ดได้เลย :) เร็วๆ นี้ :)
อัปเดต:

รุ่นจอแสดงผลคริสตัลเหลว (LCD) 1602 (เอกสารข้อมูล) เป็นตัวเลือกที่ยอดเยี่ยมสำหรับโครงการของคุณ

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

หน้าสัมผัสและแผนภาพการเชื่อมต่อของ LCD 1602 กับ Arduino

หมุดบนจอแสดงผลนี้มีหมายเลขตั้งแต่ 1 ถึง 16 ซึ่งอยู่ที่ด้านหลังของกระดาน วิธีการเชื่อมต่อกับ Arduino แสดงไว้ในตารางด้านล่าง

โต๊ะ 1. เชื่อมต่อพิน LCD 1620 เข้ากับ Arduino

การเชื่อมต่อ 1602 กับ Arduino หากจอแสดงผล 1602 ได้รับพลังงานจาก Arduino ผ่านสาย USB 5 โวลต์และพินที่เกี่ยวข้อง สามารถใช้ค่า 2 kOhm สำหรับพินคอนทราสต์ของจอแสดงผล (ขั้วต่อที่ 3 - คอนทราสต์) สำหรับหน้าสัมผัส LED+ ด้านหลัง คุณสามารถใช้ตัวต้านทาน 100 โอห์มได้ คุณยังสามารถใช้ตัวต้านทานแบบปรับค่าได้ - โพเทนชิออมิเตอร์เพื่อปรับคอนทราสต์ด้วยตนเอง

ตามตารางที่ 1 และแผนภาพด้านล่าง ให้เชื่อมต่อจอแสดงผล LCD ของคุณกับ Arduino ในการเชื่อมต่อคุณจะต้องมีชุดตัวนำ ขอแนะนำให้ใช้สายไฟที่มีสีต่างกันเพื่อหลีกเลี่ยงความสับสน

โต๊ะ 2. สีตัวนำที่ต้องการ

แผนภาพการเชื่อมต่อสำหรับจอแสดงผล LCD 1602 ถึง Arduino:

ตัวอย่างโปรแกรมพื้นฐานสำหรับการทำงาน LCD 1602 กับ Arduino

ตัวอย่างนี้ใช้พิน Arduino 0, 1, 2, 3, 4 และ 5 เพื่อเชื่อมต่อพิน 4, 6, 11, 12, 13 และ 14 จากจอแสดงผล 1602 (ดูตารางที่ 1) หลังจากนั้นในโค้ด Arduino เราจะเริ่มต้น lcd() ดังนี้:

จอแอลซีดีลิควิดคริสตัล (0, 1, 2, 3, 4, 5);

โค้ดชิ้นนี้จะอธิบายให้ Arduino ทราบอย่างชัดเจนถึงวิธีการเชื่อมต่อจอ LCD

คุณสามารถดาวน์โหลดไฟล์ต้นฉบับทั้งหมดของโครงการสถานีตรวจอากาศซึ่งใช้จอแสดงผล LCD 1602 ได้จากลิงก์นี้

LCD 1602A, Arduino และเซ็นเซอร์วัดแสง (โฟโตรีซีสเตอร์)

ในตัวอย่างเราจะดูการเชื่อมต่อการดัดแปลงจอแสดงผล - 1602A และโฟโตรีซีสเตอร์ จากโปรเจ็กต์นี้เราจะสามารถแสดงค่าตัวเลขตามสัดส่วนกับความเข้มของแสงบนจอแสดงผลได้

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

วัสดุที่จำเป็น

• 1 Arduino UNO;
• 1 เขียงหั่นขนม (63 ราง)
• เซ็นเซอร์วัดแสง 1 ตัว (โฟโตรีซีสเตอร์);
• 1 โพเทนชิออมิเตอร์ 50 kOhm;
• 1 จอ LCD 1602A;
• ตัวต้านทาน 1 ตัว 10 kOhm;
• ขั้วต่อ 1 ราง (16 พิน);
• สายยูเอสบี 1 เส้น

จอแสดงผล LCD 1602A

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

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

การเชื่อมต่อจอแสดงผล 1602A กับ Arduino

สิ่งแรกที่คุณต้องทำคือเปิดจอแสดงผล เชื่อมต่อสายเคเบิลทั้งสองเส้นตั้งแต่ +5 โวลต์และกราวด์เข้ากับแถวบวก/ลบที่สอดคล้องกันบนเขียงหั่นขนม

เชื่อมต่อ: พิน 5 โวลต์ (5V) จาก Arduino ไปยังแทร็กเขียงหั่นขนมอันใดอันหนึ่ง

เชื่อมต่อ: กราวด์ของ Arduino (GND) ปักหมุดไว้ที่แทร็กอื่น (เขียงหั่นขนม)

หลังจากนั้นเราเชื่อมต่อพลังของหน้าจอและแบ็คไลท์เข้ากับแทร็กบนเขียงหั่นขนมซึ่งเราได้รับ 5 โวลต์และลบ

เชื่อมต่อ: แทร็ก GND (ลบ) บนเขียงหั่นขนมเพื่อปักหมุด 1 บนหน้าจอ LCD (มีป้ายกำกับว่า VSS)

เชื่อมต่อ: แทร็ก 5 โวลต์ (บวก) บนเขียงหั่นขนมเพื่อปักหมุด 2 บนหน้าจอ LCD (มีป้ายกำกับ VDD)

เชื่อมต่อ: แทร็ก 5 โวลต์ (บวก) บนเขียงหั่นขนมเพื่อปักหมุด 15 บนหน้าจอ LCD (มีป้ายกำกับ A)

เชื่อมต่อ: แทร็ก GND (ลบ) บนเขียงหั่นขนมเพื่อปักหมุด 16 บนหน้าจอ LCD (มีป้ายกำกับ K)

เราเชื่อมต่อ Arduino ของเรากับคอมพิวเตอร์ส่วนบุคคลผ่านสาย USB และ voila! หน้าจอควรเปิดขึ้น

ขั้นตอนต่อไปคือการเชื่อมต่อโพเทนชิออมิเตอร์เพื่อปรับคอนทราสต์ของจอแสดงผล ไกด์ส่วนใหญ่ใช้โพเทนชิโอมิเตอร์ 10,000 โอห์ม แต่ 50,000 โอห์มก็ใช้ได้เช่นกัน เนื่องจากค่าความต้านทานที่มีช่วงกว้างกว่าที่เอาท์พุตของโพเทนชิออมิเตอร์ การปรับที่แม่นยำยิ่งขึ้นจึงกลายเป็นเรื่องยากมากขึ้น แต่สำหรับเราในกรณีนี้ สิ่งนี้ไม่สำคัญ ติดตั้งโพเทนชิออมิเตอร์บนเขียงหั่นขนมและเชื่อมต่อพินทั้งสามตัว

เชื่อมต่อ: พินแรกบนโพเทนชิออมิเตอร์ไปที่ขั้วลบบนเขียงหั่นขนม

เชื่อมต่อ: พินกลางของโพเทนชิออมิเตอร์เพื่อพิน 3 บนจอแสดงผล (มีป้ายกำกับ V0)

เชื่อมต่อ: พินที่สามบนโพเทนชิออมิเตอร์ไปที่ขั้วบวกบนเขียงหั่นขนม

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

มาต่อกันเลย ตอนนี้เราจำเป็นต้องสื่อสารระหว่าง Arduino และ 1602A LCD เพื่อแสดงอักขระ

ในการดำเนินการนี้ ให้เชื่อมต่อพิน 4 พินของจอแสดงผล (RS) เข้ากับ 7 พินของ Arduino (ขั้วต่อสีเหลือง) แสดงพิน 5 (RW) - ไปที่แถวของพินกราวด์บนเขียงหั่นขนม (สายสีดำ)

แสดงพิน 6 (E) - ไปยัง Arduino pin 8 (PWM)

แสดงพิน 11 (D4) - ถึง Arduino pin 9 (PWM)

แสดงพิน 12 (D5) - ถึง Arduino pin 10 (PWM)

แสดงพิน 13 (D6) - ไปยัง Arduino pin 11 (PWM)

แสดงพิน 14 (D7) - ถึง Arduino pin 12 (PWM)

โปรแกรมสำหรับ Arduino IDE - แสดงข้อความบนจอแสดงผล 1602A

โค้ดที่นำเสนอด้านล่างนี้จะต้องคัดลอกและวางลงใน Arduino IDE และโหลดลงบนบอร์ด:

#รวม <LiquidCrystal.h>

จอแอลซีดีลิควิดคริสตัล (7, 8, 9, 10, 11, 12);

จอแอลซีดี. เริ่มต้น (16, 2);

จอแอลซีดี setCursor (0,1);

lcd.write("แสง: ");

หลังจากโหลดโปรแกรมลงบนบอร์ดแล้ว ข้อความต่อไปนี้จะปรากฏบนบรรทัดที่สองของจอแสดงผล:

"สวัสดีชาวโลก!" ชนิดหนึ่ง เปิดตัวบน LCD 1602A ฉันขอแสดงความยินดีกับคุณ

เราเชื่อมต่อโฟโตรีซีสเตอร์และอัปโหลดโปรแกรมทั้งหมดไปยัง Arduino

ตอนนี้เรามาเชื่อมต่อโฟโตรีซีสเตอร์กัน เชื่อมต่อสายไฟสามเส้นเข้ากับรางอิสระบนเขียงหั่นขนม (เรียกว่า 1, 2, 3) เว้นที่ว่างบนรางสำหรับเซ็นเซอร์วัดแสงและตัวต้านทาน

เราเชื่อมต่อราง GND จากเขียงหั่นขนมกับราง 1 A0 (อินพุตอะนาล็อก) จาก Arduino - ถึงราง 2. 5 โวลต์จากเขียงหั่นขนม - ถึงราง 3

ต่อไปเราจะเชื่อมต่อเซ็นเซอร์และตัวต้านทานเข้ากับรางที่เตรียมไว้ ขาไหนลงพื้นและขาไหนจ่ายไฟไม่สำคัญสำหรับเซ็นเซอร์วัดแสงและตัวต้านทานของเรา (ไม่เหมือนกับ LED ซึ่งมีแคโทดและแอโนด) ดังนั้นจึงไม่มีความสับสนที่นี่

เราเชื่อมต่อเซ็นเซอร์วัดแสงเข้ากับราง 1 และราง 2 ตัวต้านทานเชื่อมต่อกับราง 2 และราง 3

ตอนนี้กลับไปที่โปรแกรมของเราและเพิ่มสองสามบรรทัดลงในส่วนว่างของฟังก์ชัน loop():

int เซ็นเซอร์ค่า = อะนาล็อกอ่าน (A0);

จอแอลซีดี setCursor (7,1);

จอแอลซีดี พิมพ์ (ค่าเซ็นเซอร์);

หลังจากอัปโหลดเวอร์ชันสุดท้ายของโปรแกรมของเราไปยัง Arduino แล้ว จอแสดงผลจะแสดงค่าระดับแสงปัจจุบัน

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

จอแสดงผลขาวดำนี้มีไฟแบ็คไลท์เสริมและสามารถแสดง 2 บรรทัดจำนวน 16 ตัวอักษร ความละเอียดของตัวอักษรคือ 5x8 พิกเซล มีการรองรับอักษรซีริลลิก

จอแสดงผลเหล่านี้มีประโยชน์อย่างไร? หน้าจอ LCD HD44780 เป็นหน้าจอมาตรฐานและมักใช้กับจอ LCD ขาวดำขนาดเล็ก ดังนั้นไลบรารีสำหรับการทำงานกับจอแสดงผลจึงเขียนโดยผู้เชี่ยวชาญ นักพัฒนา Arduino ได้เขียนไลบรารีสำหรับแพลตฟอร์มของตน และเรียกว่า LiquidCrystal เราใช้มันเพื่อทำงานกับจอแสดงผลที่ฉันเลือก

ในการเชื่อมต่อหน้าจอ LCD เราจำเป็นต้องมีส่วนประกอบดังต่อไปนี้

• Arduino ใด ๆ (ในกรณีของเรา Arduino UNO)
• จอแสดงผล LCD ขึ้นอยู่กับ HD44780
• เขียงหั่นขนม
• การเชื่อมต่อสายไฟ
• โพเทนชิออมิเตอร์ (อุปกรณ์เสริม)

การเชื่อมต่อจอภาพ LCD

การเชื่อมต่อหน้าจอ LCD เข้ากับ Arduinoไม่ยากแม้แต่กับเด็ก ติดหน้าจอเข้ากับเขียงหั่นขนมและเชื่อมต่อพลังงาน +5 V และกราวด์จาก Arduino เข้ากับรางจ่ายไฟของเขียงหั่นขนมดังที่แสดงในรูปภาพ (เนื่องจากเราจะใช้พลังงานและกราวด์หลายครั้ง การเชื่อมต่อกับรางจะสะดวกกว่า และโดยทั่วไป คุณต้องคุ้นเคยกับการเชื่อมต่อด้วยวิธีนี้)

สำหรับการทำงานเต็มรูปแบบของ Arduino กับจอแสดงผล เราจะเชื่อมต่อ 12 พิน:

• 1 - กับ กราวด์ ⇨ GND
• 2 - Vdd, กำลัง ⇨ +5 V
• 3 - Vo, การควบคุมแรงดันไฟฟ้าคอนทราสต์ ⇨ เอาท์พุตโพเทนชิโอมิเตอร์
• 4 - RS, ลงทะเบียนเลือก ⇨ pin 12 Arduino
• 5 - R/W, อ่าน/เขียน ⇨ กราวด์ (โหมดเขียน)
• 6 - E หรือที่รู้จักในชื่อ Enable, Fall strobe ⇨ pin 11 Arduino
• 7-10 - DB0-DB3 บิตลำดับต่ำของอินเทอร์เฟซ 8 บิต ไม่ได้เชื่อมต่อ
• 11-14 - DB4-DB7 บิตสูงของอินเทอร์เฟซ ⇨ พิน 5-2 Arduino
• 15 - A, แหล่งจ่ายไฟสำหรับแบ็คไลท์ ⇨ +5 V
• 16 - K กราวด์สำหรับแบ็คไลท์ ⇨ GND

จอแสดงผลนี้เหมือนกับจอแสดงผลอื่นๆ บนคอนโทรลเลอร์ HD44780 รองรับตัวเลือกอินเทอร์เฟซแบบขนานสองตัว:

• 8 บิต, พิน DB0-DB7, 1 ไบต์ (8 บิต) จะถูกถ่ายโอนต่อรอบสัญญาณนาฬิกา
• 4 บิต, พิน DB4-DB7, ครึ่งไบต์จะถูกถ่ายโอนต่อรอบสัญญาณนาฬิกา (4 บิต)

การใช้ตัวเลือก 8 บิตไม่มีประโยชน์เพราะต้องใช้ขามากขึ้นและยังไม่มีความเร็วเพิ่มขึ้น: อัตรารีเฟรชจอแสดงผลไม่เกิน 10 ครั้งต่อวินาทีดังนั้นเราจึงยังไม่สามารถเห็นได้ ข้อมูลที่อัปเดตบ่อยครั้ง ดังนั้นเราจึงปล่อยพิน DB0-DB3 ไว้โดยไม่เชื่อมต่อ

เชื่อมต่อหน้าจอแล้วพร้อมรับข้อมูล สิ่งที่เหลืออยู่คือการเขียนโปรแกรมสำหรับ Arduino

การเขียนโปรแกรม

ในการส่งออกข้อความจาก Arduino เราจะใช้ไลบรารี Liquid Crystal ซึ่งเราได้พูดถึงข้างต้น

ในการใช้งานเซ็นเซอร์บน Arduino คุณต้องดาวน์โหลดและติดตั้งไลบรารี DHT11

คุณสามารถดาวน์โหลดห้องสมุดได้ที่นี่

หลังจากที่เราดาวน์โหลดไลบรารีที่ต้องการแล้ว เราจำเป็นต้องติดตั้งอย่างถูกต้อง ติดตั้ง. ไฟล์ที่ดาวน์โหลดจะต้องถูกย้ายไปยังเส้นทางต่อไปนี้:

ไฟล์ Disk C Progtam ไลบรารี Arduino

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

/* รวมไลบรารีสำหรับการทำงานกับ LCD */
#รวม

/* สร้างวัตถุจอแสดงผล LCD โดยใช้ตัวสร้างคลาส LiquidCrystal
* มี 6 ข้อโต้แย้ง ไลบรารีจะกำหนดตามจำนวนอาร์กิวเมนต์
* ที่คุณต้องใช้อินเทอร์เฟซ 4 บิต
* เราระบุว่าหมุด Arduino ตัวใดที่หมุดแสดงผลเชื่อมต่อกับ:
*อาร์เอส อี DB4 DB5 DB6 DB7
*/
จอแอลซีดีลิควิดคริสตัล (12, 11, 5, 4, 3, 2);

การตั้งค่าเป็นโมฆะ()
{
/* เริ่มต้นการแสดงผล: 2 บรรทัด 16 ตัวอักษร */
จอแอลซีดี เริ่มต้น(16, 2);
/* แสดงวลี */
จอแอลซีดี print("สวัสดีจาก HelpDuino!");
}

เป็นโมฆะวน()
{
/* เลื่อนเคอร์เซอร์ไปที่คอลัมน์ 1 ของแถวที่ 2 การนับเลขเริ่มต้นจากศูนย์
* อาร์กิวเมนต์แรกคือหมายเลขคอลัมน์
*/
จอแอลซีดี ตั้งเคอร์เซอร์ (0, 1);
/* แสดงจำนวนวินาทีที่ผ่านไปนับตั้งแต่ Arduino เริ่มทำงาน */
จอแอลซีดี พิมพ์(มิลลิวินาที()/1000);
}

นี่คือสิ่งที่คุณควรได้รับนี่คือแบบร่างที่ง่ายที่สุดโดยมีเพียง 4 บรรทัดหลัก แต่คุณสามารถคิดออกและใช้หลักการนี้เพื่อสร้างสิ่งที่คุณต้องการ!