i2c կապ. LCM1602 LCD էկրանի միացում I2C-ով Arduino-ին

  • FC-113 մոդուլը հիմնված է PCF8574T չիպի վրա, որը 8-բիթանոց հերթափոխի ռեգիստր է՝ I/O ընդլայնող սերիական ավտոբուս I2C. Նկարում միկրոշրջանը նշանակված է DD1:
  • R1 - հարմարվողական, LCD էկրանի հակադրությունը կարգավորելու համար:
  • Jumper J1-ն օգտագործվում է էկրանի հետևի լույսը միացնելու համար:
  • 1…16 մոդուլները օգտագործվում են մոդուլը LCD էկրանի կապումներին միացնելու համար:
  • Սարքի I2C հասցեն փոխելու համար անհրաժեշտ են A1 ... A3 կոնտակտային բարձիկներ: Զոդելով համապատասխան ցատկերները՝ կարող եք փոխել սարքի հասցեն։ Աղյուսակը ցույց է տալիս հասցեների և ցատկերների միջև համապատասխանությունը՝ «0»-ը համապատասխանում է բաց միացմանը, «1»-ը՝ տեղադրված է jumper: Լռելյայնորեն, բոլոր 3 ցատկողները բաց են և սարքի հասցեն 0x27.

2 LCD էկրանի միացման դիագրամ Arduino-ին I2C արձանագրության միջոցով

Մոդուլը միացված է Arduino-ին որպես ստանդարտ I2C ավտոբուսի համար. մոդուլի SDA ելքը միացված է A4 անալոգային պորտին, SCL ելքը միացված է Arduino-ի A5 անալոգային պորտին: Մոդուլը սնուցվում է +5 Վ Arduino-ից: Մոդուլն ինքնին միացված է 1…16 կապումներով 1…16 LCD էկրանի համապատասխան կապանքներին:


3 Գրադարան աշխատանքի համար I2C արձանագրության միջոցով

Այժմ մեզ անհրաժեշտ է գրադարան՝ I2C ինտերֆեյսի միջոցով LCD-ով աշխատելու համար: Դուք կարող եք օգտագործել, օրինակ, այս մեկը (հղումը «Ներբեռնեք նմուշի կոդը և գրադարանը» տողում):

Ներբեռնված արխիվ LiquidCrystal_I2Cv1-1.rar unzip դեպի թղթապանակ \գրադարաններ\, որը գտնվում է Arduino IDE գրացուցակում։

Գրադարանը աջակցում է LCD էկրանների ստանդարտ գործառույթների մի շարք.

ԳործառույթՆպատակը
LiquidCrystal () ստեղծում է տեսակի փոփոխական LiquidCrystal և ընդունում է ցուցադրման միացման պարամետրերը (փին թվերը);
սկսել () LCD էկրանի սկզբնավորում, պարամետրերի կարգավորում (գծերի և նշանների քանակը);
պարզ () մաքրել էկրանը և կուրսորը վերադարձնել իր սկզբնական դիրքին.
տուն() կուրսորի վերադարձը սկզբնական դիրքին;
setCursor () կուրսորը դնել տվյալ դիրքում;
գրել () ցուցադրում է նիշը LCD էկրանին;
տպել () ցուցադրում է տեքստը LCD էկրանին;
կուրսոր () ցույց է տալիս կուրսորը, այսինքն. հաջորդ նիշի տակ ընդգծելով;
noCursor () թաքցնում է կուրսորը;
թարթել () կուրսորը թարթում է;
noBlink () չեղարկել թարթումը;
ոչ ցուցադրում () էկրանն անջատել՝ ցուցադրված բոլոր տեղեկությունները պահպանելիս.
ցուցադրում () էկրանի միացում՝ ցուցադրված բոլոր տեղեկությունները պահպանելիս.
scrollDisplayLeft() էկրանի բովանդակությունը ոլորել 1 դիրք դեպի ձախ;
scrollDisplayRight() էկրանի բովանդակությունը ոլորել 1 դիրք դեպի աջ;
autoscroll () միացնել ավտոմատ ոլորումը;
noAutoscroll () անջատել ավտոմատ ոլորումը;
ձախից աջ () սահմանում է տեքստի ուղղությունը ձախից աջ;
rightToLeft () տեքստի ուղղությունը աջից ձախ;
createChar () ստեղծում է հատուկ խորհրդանիշ 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 16x2 LCD էկրանի համար void setup()( lcd.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"); } void loop() (// թարթել վերջին նիշը lcd setCursor(13, 1); // կուրսորը տեղափոխել տող 2, նիշ 1 lcd.print("\t"); ուշացում (500); lcd.setCursor (13, 1); // կուրսորը տեղափոխել տող 2, նիշ 1 lcd.print(" "); ուշացում (500); }

Ի դեպ, հրամանով գրված նիշերը lcd.createChar();մնալ էկրանի հիշողության մեջ նույնիսկ հոսանքն անջատելուց հետո: գրված են 1602 էկրանի ROM-ում:

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 ավտոբուս

Որպես բոնուս, հաշվի առեք LCD էկրանի վրա լատիներեն «A», «B» և «C» նիշերի թողարկման ժամանակային դիագրամը: Այս նիշերը պահվում են դիսփլեյի ROM-ում և ցուցադրվում են էկրանին՝ պարզապես իրենց հասցեն էկրանին փոխանցելով: Դիագրամը վերցված է էկրանի RS, RW, E, D4, D5, D6 և D7 ելքերից, այսինքն. արդեն FC-113 «I2C զուգահեռ ավտոբուս» փոխարկիչից հետո։ Կարելի է ասել, որ մի փոքր «խորը» ենք սուզվում «երկաթի» մեջ։


1602 LCD էկրանի վրա լատիներեն «A», «B» և «C» տառերը ցուցադրելու ժամանակի դիագրամ

Դիագրամը ցույց է տալիս, որ էկրանի ROM-ում գտնվող նիշերը (տե՛ս տվյալների աղյուսակի 11-րդ էջը, ստորև նշված հղումը) փոխանցվում են երկու նիշերով, որոնցից առաջինը որոշում է աղյուսակի սյունակի համարը, իսկ երկրորդը՝ տողի համարը: Այս դեպքում տվյալները «կողպվում են» գծի վրա ազդանշանի եզրին Ե(Միացնել) և գիծը ՌՍ(Գրանցվել ընտրել, գրանցել ընտրություն) գտնվում է տրամաբանական մեկ վիճակում, ինչը նշանակում է տվյալների փոխանցում։ RS գծի ցածր վիճակը նշանակում է հրահանգների փոխանցում, որը մենք տեսնում ենք յուրաքանչյուր նիշի փոխանցումից առաջ։ IN այս դեպքըփոխանցվում է վագոնի վերադարձի հրահանգի կոդը LCD էկրանի դիրքին (0, 0), որը կարելի է պարզել նաև ուսումնասիրելով. տեխնիկական նկարագրությունըցուցադրել.

Եվ ևս մեկ օրինակ. Ժամանակի այս դիագրամը ցույց է տալիս LCD-ի վրա Սրտի նշանի ցուցադրումը:


Կրկին առաջին երկու ազդակները միացնելհամապատասխանել հրահանգներին Տուն()(0000 0010 2) - փոխադրման վերադարձ դեպի դիրք (0; 0), իսկ երկրորդ երկուսը - ելք դեպի LCD էկրան, որը պահվում է հիշողության բջիջում 3 10 (0000 0011 2) «Սիրտ» խորհրդանիշը (հրահանգ lcd.createChar (3, սիրտ);էսքիզ):

Թերևս շուկայում ամենահայտնի էկրաններից մեկը: Կառուցված է հայտնի HD44780U կարգավորիչի վրա: Մոդելի անունից հետևում է, որ էկրանը բաղկացած է 16 նիշից բաղկացած երկու տողից։ Ռուսաց լեզվի աջակցություն այս հարցում կոնկրետ մոդելՈչ

Sh2s տվյալների ավտոբուսը թույլ է տալիս երկու լարերի միջոցով միացնել մինչև 127 սարք և միաժամանակ։ Այս I2C-ն ներդրված է PCF8574T չիպի վրա:

Միացման դիագրամ.

Կապույտ բան - փոփոխական դիմադրություն, թույլ է տալիս կարգավորել էկրանի հակադրությունը:

Ձախ կողմում գտնվող jumper-ը պատասխանատու է էկրանի հետին լուսավորության համար:

4 փինից բաղկացած բլոկը միացված է arduino-ին այսպես.

GND-GND
VCC - 5V
SDA - A4 (եթե Arduino MEGA, ապա դեպի D20)
SCL - A5 (եթե Arduino MEGA, ապա դեպի D21)

Գրադարան

Էսքիզ

Ցուցադրումը կարող է ունենալ այլ IIC հասցե, 0x27-ի փոխարեն այն կարող է պարզվել 0x3F: Հասցեն ճշգրիտ որոշելու համար կարող եք օգտագործել i2c սարքի սկաները:

#ներառում #ներառում //սահմանել LCD էկրանի հասցեն 0x27, 16 նիշ, 2 տող LiquidCrystal_I2C LCD (0x27, 16, 2); void setup() ( lcd.init(); // Նախաձեռնել էկրանը // միացնել հետին լույսը lcd.backlight(); //Սահմանել այն դիրքը, որտեղից սկսվում է տեքստը: lcd.setCursor (2, 0); //ելքային գիծ 1 lcd.print («Բարև, աշխարհ»); //նմանապես ցուցադրել երկրորդ տողը lcd.setCursor (1, 1); lcd.print («www.site»); ) անվավեր հանգույց () ()

LCD I2C մոդուլը թույլ է տալիս միացնել նիշերի ցուցադրումը Arduino տախտակին ընդամենը երկու ազդանշանային լարով:

Օգտագործված բաղադրիչներ (գնել Չինաստանից).

. կառավարման տախտակ

. Միացնող լարեր

Հիմնական տեխնիկական բնութագրերը.

Էկրան՝ նիշ 16x02 կամ 20x04
. Լուսավորություն. Կապույտ սպիտակ նիշերով
. Հակադրություն. կարգավորելի է պոտենցիոմետրով
. Մատակարարման լարումը` 5 Վ
. Ինտերֆեյս՝ I2C
. I2C հասցե՝ 0x27
. Չափերը՝ 82 մմ x 35 մմ x 18 մմ

Միացում Arduino-ին

Մոդուլը հագեցած է չորս փին 2,54 մմ միակցիչով

SCLՍերիական ժամացույցի գիծ (Serial Clock)

SDA: սերիական տվյալների գիծ (Serial DAta)

VCC«+» հզորություն

GND: "-" ուժ

Տարբեր կարգավորիչների վրա հիմնված Arduino տախտակների I2C ինտերֆեյսի համար պատասխանատու կապերը տարբեր են

Այս մոդուլի հետ աշխատելու համար անհրաժեշտ է տեղադրել LiquidCrystal_I2C1602V1 գրադարանը

Ներբեռնեք, բացեք փաթեթավորումը և գցեք գրադարանների թղթապանակը Arduino թղթապանակում: Եթե ​​գրադարանն ավելացնելու պահին Arduino IDE-ն բաց էր, վերագործարկեք միջավայրը։

Եկեք անմիջապես անցնենք էսքիզին: Այս օրինակում մենք կցուցադրենք «Բարև, աշխարհ» ստանդարտը: և մեր համայնքի հասցեին։

կոդը օրինակ.

#ներառում #ներառում LiquidCrystal_I2C LCD (0x27,16,2); /* Սահմանեք էկրանի հասցեն և չափը: 20x04 էկրանով LCD I2C մոդուլ օգտագործելիս կոդում ոչինչ պետք չէ փոխել, պարզապես անհրաժեշտ է ճիշտ չափը սահմանել */անվավեր կարգավորում() (lcd.init(); // Նախաձեռնել LCD-ը lcd.backlight(); // միացնել հետին լույսը // Կուրսորը 1-ին տողի սկզբում է lcd.print («Բարև, աշխարհ»); // Ցուցադրել տեքստային lcd setCursor (0, 1); // Կուրսորը դրեք 2-րդ տողի սկզբին lcd.print ("կայք"); // Ցուցադրել տեքստը ) void հանգույց () { }

Ստեղծելով ձեր սեփական խորհրդանիշները

Մենք պարզեցինք տեքստի ելքը, անգլերեն այբուբենի տառերը կարված են էկրանի ներսում կարգավորիչի հիշողության մեջ և դրանց հետ կապված խնդիրներ չկան: Բայց ինչ անել, եթե ցանկալի նիշը չկա վերահսկիչի հիշողության մեջ:

Կարևոր չէ, պահանջվող նիշը կարելի է ձեռքով պատրաստել: Այս մեթոդըմասամբ 7 նիշանոց սահմանաչափը կօգնի լուծել ելքային խնդիրը։

Բջիջը, որը մենք դիտարկում ենք էկրաններում, ունի 5x8 պիքսել թույլատրություն: Սիմվոլ ստեղծելու ամբողջ խնդիրը հանգում է նրան, որ մի քիչ դիմակ գրելը և դրա մեջ տեղադրելը այն վայրերում, որտեղ կետերը պետք է այրվեն, իսկ զրոյականները, որտեղ ոչ:

Ստորև բերված օրինակում եկեք նկարենք ժպտացող դեմք:

կոդը օրինակ.

//Փորձարկվել է Arduino IDE 1.0.5-ի վրա // Ավելացնել անհրաժեշտ գրադարանները#ներառում #ներառում // Ժպիտի խորհրդանիշ Bitmaskբայթ ժպիտ = ( B00010, B00001, B11001, B00001, B11001, B00001, B00010, ); LiquidCrystal_I2C LCD (0x27,20,4); // Սահմանեք էկրանի հասցեն և չափը:անվավեր կարգավորում() (lcd.init(); // Նախաձեռնել LCD-ը lcd.backlight(); // միացնել հետին լույսը // Ստեղծեք խորհրդանիշ համարը 0 lcd.createChar (1, ժպտացեք); lcd.setCursor (0, 0); // Կուրսորը դրեք 1-ին տողի սկզբում lcd.print ("\1"); // Ցուցադրել սմայլը (նիշ թիվ 1) - «\1») անվավեր հանգույց () { }

Խորհրդանիշների հեշտ ստեղծման ծրագիր

Մեկնաբանություններում համայնքի անդամներից մեկը բացել է նիշերի գեներատորի հղումը

Ես այն ստացել եմ այստեղից լավ խանութ Chip Resistor-ը ևս մեկ սարք է, որը կարելի է ուսումնասիրել և օգտագործել օգտակար սարքեր. Պարզվեց, որ այս սարքը սրվել է HD44780 կարգավորիչի հսկողության ներքո LCD էկրանը կառավարելու համար, 4-բիթ ռեժիմում: Այդ նպատակով տախտակի վրա տեղադրվում է միկրոսխեման, որը I2C ավտոբուսի փոխարկիչն է զուգահեռ 8-բիթանոց պորտի։

Տախտակը բաժանված է այնպես, որ այն կարելի է անմիջապես հատել LCD էկրանով: Մուտքը սնուցվում է և I2C գծեր: Տախտակն անմիջապես ունի SCL և SDA գծերի վրա ձգվող դիմադրություններ, կոնտրաստը կարգավորելու պոտենցիոմետր և էկրանը սնուցելու համար:

Աջ ցատկողը միացնում/անջատում է հետևի լույսը: Այնուհետև փորձարկողով զինված կազմվեց հետևյալ ափսեը. Մոդուլն ուսումնասիրելուց հետո պարզվել է, որ P3վերահսկում է հետևի լույսը: Եթե ​​ցատկողը դրված է, ապա 1-ը միացնում է հետին լույսը, իսկ 0-ն անջատում է այն: Երբ jumper-ը հանվում է, հետևի լույսը միշտ անջատված է: Այնուհետև, որոշվեց լրացնել axlib գրադարանը I2C ավտոբուսի հետ աշխատելու գործառույթներով (ծրագրային ապահովման ներդրում) և PCF8574 չիպի վերահսկման գործառույթներով: Մի խոսքով, ինչպես է աշխատում մոդուլը: Բայթերը զուգահեռ դուրս բերելու համար դրա համար անհրաժեշտ է միկրոսխեմայի հասցեն ուղարկել I2C ավտոբուսին (լռելյայն այն 0x4E է: Կարող եք նաև փոխել հասցեն՝ սալիկի վրա ցատկողներ զոդելով և երեք նվազագույնի արժեքը փոխելով: հասցեի նշանակալի թվանշանները), ապա ACK ստանալուց հետո ուղարկվում է տվյալների բայթ: Այն բանից հետո, երբ չիպը արձագանքում է ACK-ով, բայթը հայտնվում է չիպի զուգահեռ պորտում: LCD-ը կառավարելու համար ես ֆունկցիաները վերցրեցի axlib գրադարանից և մի փոքր վերամշակեցի դրանք՝ I2C ավտոբուսի հետ աշխատելու համար: #ներառում #ներառում #ներառում #ներառում #define ADD 0x4E // Չիպի հասցե /* LCD չիպ RS P0 RW P1 EN P2 D4 P4 D5 P5 D6 P6 D7 P7 Հետևի լույսը միացված է P3-ին: 1 միացված, 0 անջատված */ // Տվյալների ելք com |= 0x04; // Ե մեկին pcf8574_byte_out (com, ADD); // Տվյալների ելք com &= 0xFB; // E զրոյի pcf8574_byte_out (com, ADD); // Տվյալների ելք) void init(void) (_delay_ms(30); com (0x30); _delay_us (40); com (0x30); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x30); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x20); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x20); // Սահմանել ընտրանքները com (0x80); // Սահմանել ընտրանքները com (0x00); // Անջատեք էկրանը com (0x80); // Անջատեք էկրանը com (0x00); // Մաքրել էկրանը com (0x10); // Մաքրել էկրանը com (0x00); com (0x60); // Սահմանեք մուտքագրման ռեժիմը com (0x00); com (0xC0); // Միացրեք էկրանը ընտրված կուրսորով) void char_out (BYTE տվյալներ) (BYTE data_h = ((տվյալներ & 0xF0) + 0x09); BYTE data_l = ((տվյալներ // Անցնել բարձր 4 բիթ data_h |= 0x04; pcf8574_byte_out (data_h, ADD); // Անցնել բարձր 4 բիթ // Անցնել բարձր 4 բիթ // Անցեք ցածր 4 բիթ // Անցեք ցածր 4 բիթ // Անցեք ցածր 4 բիթ) void str_out(BYTE *str) ( while((*str) != "\0") (char_out(*str); str++; ) ) int main(void) (init(); str_out("ЁPҐBET MҐP!" Մինչդեռ (1) ())Հենց այն, ինչ կատարվում է այստեղ։ Նախ, մենք ներառում ենք գրադարաններ I2C-ի և PCF8574-ի համար: Ես արդեն գրել եմ I2C-ի մասին, այնպես որ ես նորից չեմ խաչի, բայց ես ձեզ կասեմ, թե ինչ է PCF8574.h-ում: Գրադարանը ներառում է ընդամենը երեք գործառույթ.
BYTE pcf8574_test (BYTE ավելացնել) ( BYTE հարցնել = ACK; ավելացնել &= 0xFE; i2c_start(); հարցնել = i2c_send_byte(add); i2c_stop(); վերադարձնել հարցումը;)Առաջին գործառույթը գրվել է ստուգելու համար, թե արդյոք սարքը ավտոբուսում է: Սկզբունքորեն, այն կարող է օգտագործվել ավտոբուսում տեղակայված ցանկացած սարքի որոնման համար: Ֆունկցիան վերցնում է ցանկալի սարքի հասցեն, և եթե այն արձագանքում է, վերադարձնում է զրո: Եթե ​​այս հասցեով սարքը ավտոբուսում չէ, այն կվերադարձնի մեկը:
BYTE pcf8574_byte_out (BYTE տվյալներ, BYTE ավելացնել) ( BYTE հարց = ACK; ավելացնել &= 0xFE; i2c_start(); հարցնել = i2c_send_byte(add); if(!ask) ask = i2c_send_byte(տվյալներ); i2c_stop(); )Այս ֆունկցիան արդեն սրվել է զուտ այս չիպի համար: Որպես փաստարկ, այն փոխանցվում է բայթ ավտոբուսին և միկրոսխեմայի հասցեին փոխանցելու համար: Ֆունկցիան նախ հարցում կկատարի չիպի հասցեով, այնուհետև բայթ կուղարկի: Եթե ​​չիպը ստացել է բայթը և պատասխանել է ACK-ով, ապա ֆունկցիան կդադարեցնի չիպը և կվերադարձնի զրո որպես հաջողված բայթ: Եվ այս պահին միկրոսխեման այս բայթը դուրս կբերի իր զուգահեռ պորտին: Հակառակ դեպքում ստանում ենք NACK և վերադարձնում ենք, փոխանցումը ձախողվել է։
BYTE pcf8574_str_out (BYTE *տվյալներ, BYTE սյունակ, BYTE ավելացնել) (BYTE հարց = ACK; ավելացնել &= 0xFE; i2c_start(); հարցնել = i2c_send_byte(ավելացնել); for(BYTE i=0; i Այս հատկությունը ստեղծվել է փորձերի համար: Այն պահանջում է ցուցիչ մեկ բայթանոց տվյալների զանգվածին, այդ բայթերի քանակին և չիպի հասցեին: Իրականում բոլոր տվյալները մեկ նստաշրջանում փոխանցելու փորձ, և ոչ թե մեկ բայթ յուրաքանչյուր նստաշրջանում: Ֆունկցիան աշխատում է, բայց այն չէր համապատասխանում LCD էկրանին: Հիմա վերադառնանք հիմնական ծրագրին: Գրադարանները միացնելուց հետո մենք սահմանում ենք միկրոսխեմայի հասցեն։ Հաջորդը lcd.h-ի անալոգիայով մենք ստեղծում ենք երեք ֆունկցիա: Տարբերությունը միայն տվյալների փոխանցման սկզբունքի մեջ է։
void com(BYTE com) (com |= 0x08; // P3-ից մեկին, որպեսզի հետին լույսը միացված լինի pcf8574_byte_out (com, ADD); // Տվյալների ելք com |= 0x04; // Ե մեկին pcf8574_byte_out (com, ADD); // Տվյալների ելք com &= 0xFB; // E զրոյի pcf8574_byte_out (com, ADD); // Տվյալների ելք } Այս ֆունկցիան միայն հրամաններ է ուղարկում էկրանին: Այսպիսով, առաջին տողը հայտնվեց 0x08 հրամանի տրամաբանական ավելացմամբ: Այս բյական անհրաժեշտ է այն պատճառով, որ մենք բայթերը փոխանցում ենք ոչ թե ուղղակիորեն LCD պորտին, այլ մեր կրկնիչի միջոցով: Այսինքն, եթե մենք բայթ ենք ներկայացրել, իսկ հետո պետք է թողարկենք միայն մեկ բիթ, ապա եթե խնդրում ենք, այն անհրաժեշտ բիթը կհատկացնի նախորդ բայթին և նորից կուղարկի պորտ։ Սա նման սառեցում է: 0x08-ով ավելացումն անհրաժեշտ է, որպեսզի մեկը մշտապես պահվի երրորդ թվանշանի վրա: Հիշո՞ւմ եք հետևի լույսը: Այս հավելումն է, որ միացնում է հետին լույսը: Այն բանից հետո, երբ մենք կանչում ենք բայթ ավտոբուսին փոխանցելու գործառույթը: Այդ մասին գրվել է վերևում. Այնուհետև բայթը ավտոբուսի վրայով փոխանցում ենք միկրոշրջան: Հաջորդը, դուք պետք է այն դնեք E միավորի վրա, ինչը իրականում անում է 0x04 բայթի տրամաբանական ավելացումը: E-ն զրոյացնելուց հետո: Այսպիսով, դուք կարող եք ցանկացած հրաման ուղարկել էկրանին միայն ինքնին հրամանը որպես արգումենտ փոխանցելով: void init(void) (_delay_ms(30); // Դադար միացումից հետո com (0x30); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x30); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x30); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x20); // Անցնել 4-բիթանոց ռեժիմի _delay_us (40); // Հրամանի կատարման հետաձգում com (0x20); // Սահմանել ընտրանքները com (0x80); // Սահմանել ընտրանքները com (0x00); // Անջատեք էկրանը com (0x80); // Անջատեք էկրանը com (0x00); // Մաքրել էկրանը com (0x10); // Մաքրել էկրանը com (0x00); // Սահմանեք մուտքագրման ռեժիմը com (0x60); // Սահմանեք մուտքագրման ռեժիմը com (0x00); // Միացրեք էկրանը ընտրված կուրսորով com (0xC0); // Միացրեք էկրանը ընտրված կուրսորով } Այս գործառույթը վերաբերում է միայն ցուցադրման սկզբնավորմանը: Հրամանների հաջորդականությունը վերցված է LCD էկրանի տվյալների թերթիկից: void char_out (BYTE տվյալներ) (BYTE data_h = ((տվյալներ & 0xF0) + 0x09); BYTE data_l = ((տվյալներ // Անցնել բարձր 4 բիթ data_h |= 0x04; pcf8574_byte_out (data_h, ADD); // Անցնել բարձր 4 բիթտվյալների_ժ &= 0xF9; pcf8574_byte_out (data_h, ADD); // Անցնել բարձր 4 բիթ pcf8574_byte_out (data_l, ADD); // Անցեք ցածր 4 բիթտվյալների_լ |= 0x04; pcf8574_byte_out (data_l, ADD); // Անցեք ցածր 4 բիթ data_l &= 0xF9; pcf8574_byte_out (data_l, ADD); // Անցեք ցածր 4 բիթ } Այս գործառույթը տվյալներ է ուղարկում LCD էկրանին: Այն կատարվում է այնպես, ինչպես հրամանները, այն տարբերությամբ, որ բայթի փոխանցումը կատարվում է սկզբում բարձր, իսկ հետո ցածրի հետ: Իսկ մնացածը նույնն է։ void str_out(BYTE *str) ( while((*str) != "\0") (char_out(*str); str++; ) )Դե, այս ֆունկցիան զուտ էկրանին տող փոխանցելու համար է: Փաստորեն, դա մեր թեմայի հետ կապ չունի։

Նախագիծ AtmelStudio 6.2-ի համար

Իրավասու 01.08.15 17:11

Ստորակետը բացակայում է։ Ճիշտ է՝ «ԲԱՐԵՎ ԱՇԽԱՐՀ»: Եվ այս սարքը սրված է ոչ միայն HD44780-ի համար։ Ձգվող դիմադրությունները տեղադրվում են վարպետի կողմից: Ըստ սպեցիֆիկացիայի՝ տվյալները գրվում են LCD կարգավորիչին նվազող E-ով: Այստեղից առաջին ֆունկցիան պարզեցված է՝ void com(BYTE com) ( com |= 0x08; // backlight pcf8574_byte_out(com | 0x04, ADD);/ / Տվյալների ելք pcf8574_byte_out (com , ADD); // E զրոյի ) Այո, իսկ մնացածը նույնպես կարող է զգալիորեն պակաս լինել: Օրինակ, void char_out (BYTE տվյալներ) կլինի ընդամենը երկու զանգ, և նույնիսկ ավելին՝ առանց լրացուցիչ փոփոխականների: LCD-ի սկզբնավորումը կատարվել է ժամանակի ճշգրտման խախտումներով:

Ալեքսեյ 02.08.15 19:11

Ստորակետի բացակայության պատճառով էկրանը չի տուժի: Այս սարքը պարզապես նախագծված է հատուկ այս կամ նմանատիպ կարգավորիչով էկրանների համար: Բայց դա միկրոսխեմա է, որն իսկապես պարզ պորտի ընդլայնող է: Ես համաձայն եմ Ե. Անհրաժեշտ են լրացուցիչ փոփոխականներ: Եթե ​​արգումենտ փոխանցեք ֆունկցիային և որոշ գործողություններ կատարեք տրամաբանությամբ, կարող են անսարքություններ առաջանալ: Արդեն հանդիպել է սա. Նախաձեռնումն իրականացվում է առանց ժամանակի խախտման: Փաստաթղթում ասվում է, որ հրամանների միջև կա 40 մկվ դադար: Շնորհիվ այն բանի, որ փոխանցումը կատարվում է i2c ավտոբուսով, որն իր հերթին ծրագրային է և դանդաղ, ժամկետներն ավելի քան կատարված են։ Եթե ​​շատ ծույլ չեք, ապա գրեք ձեր տարբերակը և ուղարկեք ինձ։ Ես կհրապարակեմ այն։ Ի վերջո, այս կայքը նախատեսված է սիրողական լսարանի համար, և բոլոր ցանկացողները կարող են արտահայտել իրենց կարծիքն ու տեսլականը MK-ի կյանքի վերաբերյալ:

Ալեքսեյ 06.08.15 09:14

Ավելացվել են ժամացույցներ էկրանը սկզբնավորելիս հարգված «Իրավասու» դիտողությամբ

Դմիտրի 14.06.16 21:57

Բարև Ալեքսեյ: PCF8574-ի հետ աշխատելու համար կարող եք գրադարան ավելացնել կոդերի գեներատորին:

Ալեքսեյ 14.06.16 22:32

Ես կմտածեմ.))

ռուսլան 21.12.16 19:54
Ալեքսեյ 21.12.16 21:53

Օ, այո. Հատկապես asme-ի կոդը: Արդուինները դա առավելագույնս կգնահատեն)))

Py.sy.
Նույնիսկ եթե դուք չեք նայում asm-ին, ապա այնտեղ ծրագիրը գրված է PIC վերահսկիչի տակ: Արդյո՞ք սա «շատ» օգտակար տեղեկատվություն է AVR մարդկանց համար: հատկապես սկսնակների համար))) PIC-ի դեմ ոչինչ չունեմ, բայց նույնիսկ PIC-ն ու AVR-ն տարբեր asm ունեն: Իսկ ինչ վերաբերվում է LCD դիսփլեյի մանրամասներին, կարող եք նայել))) Ճիշտ է, ես էլ CVAVR-ի տակ եմ գրել, բայց բոլոր հրամանները տեսակավորվել ու տեսակավորվել են։ Բայց ամեն դեպքում ինքներդ որոշեք, թե որտեղ է ավելի պարզ գրված))) Հեղինակը գրում է, ընթերցողն ընտրում։

GeK 04.01.17 12:52

«I2C չիպի հասցե (կանխադրված է 0x4E»

Հասցեի վերին 4 բիթերը ամրագրված են,
PCF8574 նախածանցը 0100 է, իսկ PCF8574A-ը 0111 է
Ստորին 3 բիթերը կախված են A2-A0 միկրոսխեմայի մուտքերի վիճակից: Լռելյայնորեն, բոլոր 3 ցատկողները բաց են, համապատասխանաբար, միկրոսխեմայի հասցեն է 0111111:
// A2 A1 A0 PCF8574 PCF8574A
// 1 1 1 0x20 0x38
// 1 1 0 0x21 0x39
// 1 0 1 0x22 0x3A
// 1 0 0 0x23 0x3B
// 0 1 1 0x24 0x3C
// 0 1 0 0x25 0x3D
// 0 0 1 0x26 0x3E
// 0 0 0 0x27 0x3F

Ալեքսեյ 04.01.17 14:27

Ինչ-որ բան խառնեցիր.
Քաղվածք միկրոսխեմայի համար փաստաթղթերից

0b01001110-ը 0x4E է
Այսպիսով, այստեղ ամեն ինչ ճիշտ է: Եվ եթե դուք պետք է փոխեք հասցեն, ապա դուք պարզապես պետք է այն փոխեք define-ում:

Յուրի 14.12.17 21:26

Լավ օր! Եվ դուք կարող եք նաև օգտագործել lcdgotoxy և lcdclear ֆունկցիայի կոդը PCF8574 ադապտերի հետ աշխատելու համար:

Ալեքսանդր 20.05.18 18:14

Լավ օր! ինչպես եք ցուցադրում ռուսերեն տեքստը:

Ալեքսեյ 20.05.18 23:04

Սա կենցաղային ցուցադրություն է MELT-ից: Նրա հիշողության մեջ կարված է կիրիլյան այբուբենը։

Ալեքսանդր 21.05.18 04:55

Լավ օր! Ես գրում եմ այնպես, ինչպես դուք ունեք AtmelStudio 6.2 նախագծում «ЁPҐBET MҐP!» լավ է ստացվում
իսկ եթե գրեք «ԲԱՐԵՎ ԱՇԽԱՐՀ»: դուրս է հանում ամեն տեսակ անհեթեթություն. Ես ունեմ երկու
Մեկում ցուցադրվող տարբերակը կարված է կիրիլիցայով: երկրորդ չինական.

Ալեքսեյ 21.05.18 09:22

Ես նախ կգրեի թեստային ծրագիր: Ամբողջ հիշողության թվարկում՝ նիշերի և դրանց հասցեների ցուցադրմամբ: Եվ հետո պարզեք, թե որն է խնդիրը: Ամենայն հավանականությամբ, նիշերի աղյուսակը չի համապատասխանում ascii աղյուսակին:

Անդրեյ 03.09.18 08:32

Բարի օր!

Չե՞ք կարող ներբեռնել Proteus-ի սխեմա:

Անդրեյ 03.09.18 10:22

Թե՞ Proteuse-ում ոչ ոք չի ստուգել:

Անդրեյ 03.09.18 10:56

Պարզվեց main_init-ը

Պավել 30.05.19 23:35

Հետաքրքիր է, ցուցադրման հասցեն 0x4E է, և եթե նույն էկրանը միացված է arduino-ին, ապա հասցեն 0x27 է:

Պավել 31.05.19 11:04

Շատ շնորհակալ եմ ձեր աշխատանքի համար: Ես նայեցի ամբողջ ինտերնետը, և վերը նշված օրինակներից ոչ մեկը չի աշխատում, բացի ձերից: Միակ բանն այն է, որ նախագծի արխիվում _delay_ ուշացումները չեն գրանցվում ցուցադրման սկզբնավորման գործառույթում, և այն համապատասխանաբար չի աշխատում:

Ալեքսեյ 06/01/19 09:52

Դե, սա ավելի շատ ցուցադրական նախագիծ է: Լավ, դուք պետք է վերաշարադրեք axlib գրադարանը, բայց հաշվի առնելով այն փաստը, որ STM32-ը և STM8-ը շարժվում են թռիչքներով և սահմաններով, AVR-ն ընդհանրապես իմաստ չունի:

Պավել 05.06.19 12:57

STM-ը չունի DIP փաթեթներ, ավելի դժվար է տպագիր տպատախտակներ պատրաստելը։ Իմ նախագծերի համար AVR հնարավորությունները բավարար են մարժանով, շատ բան կարող է տեղավորվել մեկ Atmega 8-ի վրա

Ալեքսեյ 05.06.19 15:20

Հա, բայց Atmega8-ն ու stm8s003-ը ինչ արժեն)))

Դմիտրի 06/07/19 00:41

Բարև Ալեքսեյ:
Կարո՞ղ եք ինձ ասել, թե ինչպես կարդալ պորտի կարգավիճակը pcf8574-ից:
Ես ուզում եմ արտաքին բլոկ սարքել, 8 GPIO i2c ավտոբուսի վրա՝ ինքն իրեն։

Դմիտրի 07.06.19 17:56

Ես ինքս կպատասխանեմ
Ֆունկցիան վերադարձնում է բայթ՝ միկրոսխեմաների պորտերի վիճակը
uint8_t pcf8574_byte_rcv (uint8_t հավելում)
{
uint8_t հարցնել = ACK;
ավելացնել |= 0b01; //ԿԱՐԴԱԼ
uint8_tdata=0;
i2c_start ();
հարցնել = i2c_send_byte (addr);
if(!ask) տվյալներ = i2c_read_byte (NACK);
i2c_stop ();

վերադարձնել տվյալները;
}

Պավել 07.06.19 20:37

Որքա՞ն արժե այն, 150 ռուբլի, ընդհանուր առմամբ ռելեի գնի համար), բայց ինչպես եք տախտակներ աճեցնում STM-ի համար: LUT-ն անվստահելի է, CNC երթուղիչը վստահ չէ, թե ինչ կպահանջվի (չփորձեցի)

LCD էկրան- հաճախակի հյուր arduino նախագծերում: Բայց բարդ սխեմաներում մենք կարող ենք ունենալ Arduino նավահանգիստների պակասի խնդիր, քանի որ անհրաժեշտ է միացնել վահան, որն ունի շատ կապում: Այս իրավիճակում ելքը կարող է լինել I2C/IICադապտեր, որը միացնում է գրեթե ստանդարտ Arduino 1602 վահանը Uno, Nano կամ Mega տախտակների հետ ընդամենը 4 կապում: Այս հոդվածում մենք կտեսնենք, թե ինչպես կարելի է միացնել LCD էկրանը I2C ինտերֆեյսով, ինչ գրադարաններ կարող են օգտագործվել, գրել կարճ էսքիզային օրինակ և վերլուծել բնորոշ սխալները:

Հեղուկ բյուրեղյա էկրան LCD 1602լավ ընտրություն է տարբեր նախագծերում նիշերի տողեր դուրս բերելու համար: Այն էժան է, կան տարբեր փոփոխություններ՝ տարբեր լուսային գույներով, հեշտությամբ կարող եք ներբեռնել պատրաստի գրադարաններ Arduino-ի էսքիզների համար։ Բայց այս էկրանի հիմնական թերությունն այն է, որ էկրանն ունի 16 թվային կապում, որոնցից առնվազն 6-ը պահանջվում է: Հետևաբար, այս LCD էկրանն առանց i2c օգտագործելը լուրջ սահմանափակումներ է ավելացնում Arduino Uno կամ Nano տախտակների համար: Եթե ​​բավարար կոնտակտներ չկան, ապա ստիպված կլինեք գնել Arduino Mega տախտակ կամ պահպանել կոնտակտները, այդ թվում՝ էկրանը միացնելով i2c-ի միջոցով։

LCD 1602 պինների համառոտ նկարագրություն

Եկեք ավելի սերտ նայենք LCD1602 կապին.

Եզրակացություններից յուրաքանչյուրն ունի իր նպատակը.

  1. Գրունտային GND;
  2. Էլեկտրաէներգիայի մատակարարում 5 Վ;
  3. Մոնիտորի հակադրության կարգավորում;
  4. Հրաման, տվյալներ;
  5. Տվյալների գրավոր և ընթերցում;
  6. միացնել;

7-14։ Տվյալների գծեր;

  1. Գումարած հետին լուսավորություն;
  2. Մինուս հետին լույս:

Ցուցադրման բնութագրերը.

  • Խորհրդանշական ցուցադրման տեսակը, հնարավոր է բեռնել նշաններ;
  • LED լույսեր;
  • Վերահսկիչ HD44780;
  • Մատակարարման լարումը 5 Վ;
  • Ձևաչափ 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 մոդուլով Port IIC/I2C/TWI/SPI ադապտեր մոդուլ 1602 Shield-ի համար, որը համատեղելի է Arduino-ի հետ
RGB հետին լուսավորված էկրան: LCD 16×2 + ստեղնաշար + Buzzer Shield Arduino-ի համար Վահան Arduino-ի համար կոճակներով և էկրանով LCD1602 LCD 1602 LCD էկրան 3D տպիչի համար (Smart Controller RAMPS 1.4-ի համար, Text LCD 20×4), SD և MicroSD քարտերի ընթերցող մոդուլ

I2C արձանագրության նկարագրությունը

Նախքան i2c ադապտերի միջոցով էկրանը arduino-ին միացնելու հարցը քննարկելը, եկեք համառոտ խոսենք հենց i2C արձանագրության մասին:

I2C / IIC(Inter-Integrated Circuit) արձանագրություն է, որն ի սկզբանե ստեղծվել է էլեկտրոնային սարքի ներսում ինտեգրալ սխեմաների փոխկապակցման համար: Մշակումը պատկանում է Philips-ին։ i2c արձանագրությունը հիմնված է 8-բիթանոց ավտոբուսի օգտագործման վրա, որն անհրաժեշտ է կառավարման էլեկտրոնիկայի բլոկները միացնելու համար, և հասցեավորման համակարգ, որի շնորհիվ կարող եք շփվել մի քանի սարքերի հետ նույն լարերով: Մենք պարզապես տվյալներ ենք փոխանցում այս կամ այն ​​սարքին՝ տվյալների փաթեթներին ավելացնելով ցանկալի տարրի նույնացուցիչը:

Ամենապարզ I2C սխեման կարող է պարունակել մեկ վարպետ (առավել հաճախ Arduino միկրոկառավարիչ) և մի քանի ստրուկներ (օրինակ, LCD էկրան): Յուրաքանչյուր սարք ունի հասցե 7-ից 127 միջակայքում: Նույն սխեմայի մեջ չպետք է լինեն նույն հասցեով երկու սարքեր:

Arduino տախտակն աջակցում է i2c-ին սարքաշարում: Այս արձանագրության միջոցով սարքերը միացնելու համար կարող եք օգտագործել A4 և A5 կապում:

I2C-ի հետ աշխատելու մի քանի առավելություններ կան.

  • Գործողության համար պահանջվում է ընդամենը 2 տող՝ SDA (տվյալների գիծ) և SCL (ժամացույցի գիծ):
  • Մեծ թվով առաջատար սարքերի միացում:
  • Զարգացման ժամանակի կրճատում.
  • Սարքերի ամբողջ հավաքածուն կառավարելու համար պահանջվում է միայն մեկ միկրոկառավարիչ:
  • Մեկ ավտոբուսին միացված միկրոսխեմաների հնարավոր քանակը սահմանափակվում է միայն առավելագույն հզորությամբ:
  • Տվյալների անվտանգության բարձր աստիճան՝ շնորհիվ սխեմաների մեջ ներկառուցված ալիքների ճնշող հատուկ ֆիլտրի:
  • Առաջացող խափանումների ախտորոշման պարզ ընթացակարգ, անսարքությունների արագ վերացում:
  • Ավտոբուսն արդեն ինտեգրված է հենց Arduino-ին, ուստի կարիք չկա լրացուցիչ ավտոբուսային ինտերֆեյսի մշակման:

Թերություններ:

  • Գծի վրա կա կոնդենսիվության սահմանափակում՝ 400 pF:
  • I2C կարգավորիչի ծրագրավորման դժվարություն, եթե ավտոբուսում կան մի քանի տարբեր սարքեր:
  • Մեծ թվով սարքերի դեպքում դժվար է դառնում տեղայնացնել ձախողումը, եթե դրանցից մեկը սխալ է սահմանում ցածր մակարդակի վիճակը:

i2c մոդուլ LCD 1602 Arduino-ի համար

Arduino-ում i2c դիսփլեյն օգտագործելու ամենաարագ և ամենահարմար միջոցը ներկառուցված պրոտոկոլի աջակցությամբ պատրաստի էկրան գնելն է։ Բայց այս էկրանները այնքան էլ շատ չեն և դրանք էժան չեն: Բայց արդեն թողարկվել են հսկայական թվով տարբեր ստանդարտ էկրաններ: Հետևաբար, այսօր առավել մատչելի և հանրաճանաչ տարբերակն է գնել և օգտագործել առանձին I2C մոդուլ՝ ադապտեր, որն ունի հետևյալ տեսքը.

Մոդուլի մի կողմում մենք տեսնում ենք i2c կապանքները՝ հիմք, հզորություն և 2 տվյալների փոխանցման համար: Մյուս ադապտերի վրա մենք տեսնում ենք արտաքին հոսանքի միակցիչները: Եվ, իհարկե, տախտակի վրա կան բազմաթիվ քորոցներ, որոնց օգնությամբ մոդուլը զոդվում է էկրանի ստանդարտ կապումներին։


I2c ելքերը օգտագործվում են Arduino տախտակին միանալու համար: Անհրաժեշտության դեպքում միացրեք արտաքին սնուցման աղբյուրը լուսավորության համար: Ներկառուցված հարմարվողականի միջոցով մենք կարող ենք կարգավորել կարգավորվող հակադրության արժեքները J

Շուկայում կարելի է գտնել LCD 1602 մոդուլներ արդեն զոդված ադապտերներով, դրանց օգտագործումը առավելագույնս պարզեցված է։ Եթե ​​դուք առանձին ադապտեր եք գնել, ապա ձեզ հարկավոր է նախապես զոդել այն մոդուլին:

LCD էկրանի միացում Arduino-ին I2C-ի միջոցով

Միանալու համար ձեզ հարկավոր է հենց Arduino տախտակը, դիսփլեյ, հացահատիկ, միացնող լարեր և պոտենցիոմետր:

Եթե ​​դուք օգտագործում եք հատուկ առանձին i2c ադապտեր, ապա նախ պետք է այն զոդել էկրանի մոդուլին: Այնտեղ դժվար է սխալվել, կարելի է նման սխեմայով առաջնորդվել։


i2c-ով միացված LCD մոնիտորը միացված է տախտակին՝ օգտագործելով չորս լար՝ երկու լար տվյալների համար, երկու լար՝ հոսանքի համար:

  • GND փին միացված է GND-ին տախտակի վրա:
  • VCC քորոցը 5 Վ է:
  • SCL-ը միացված է A5 կապին:
  • SDA-ն միացված է կապին A-ին:

Եվ դա բոլորը! Ոչ մի լարերի սարդոստայններ, որոնցում շատ հեշտ է շփոթվել։ Միևնույն ժամանակ, մենք կարող ենք պարզապես գրադարաններին վստահել i2C արձանագրության ներդրման ողջ բարդությունը։

Գրադարաններ i2c LCD էկրանով աշխատելու համար

I2C ավտոբուսի միջոցով Arduino-ն LCD 1602-ի հետ փոխկապակցելու համար ձեզ անհրաժեշտ կլինի առնվազն երկու գրադարան.

  • I2C-ի հետ աշխատելու Wire.h գրադարանն արդեն հասանելի է ստանդարտ Arduino IDE ծրագրում:
  • LiquidCrystal_I2C.h գրադարանը, որը ներառում է I2C ավտոբուսի միջոցով մոնիտորը կառավարելու հրամանների լայն տեսականի և թույլ է տալիս ուրվագիծն ավելի հեշտ և կարճ դարձնել: Դուք պետք է լրացուցիչ տեղադրեք գրադարանը էկրանը միացնելուց հետո դուք պետք է լրացուցիչ տեղադրեք LiquidCrystal_I2C.h գրադարանը

Բոլոր անհրաժեշտ գրադարանները էսքիզին միացնելուց հետո մենք ստեղծում ենք օբյեկտ և կարող ենք օգտագործել դրա բոլոր գործառույթները։ Փորձարկման համար եկեք բեռնենք հետևյալ ստանդարտ ուրվագիծը օրինակից։

#ներառում #ներառում // Գրադարանի միացում //#include // այլընտրանքային գրադարանի միացում LiquidCrystal_I2C lcd(0x27,16,2); ( () ( 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() - ցույց տալ/թաքցնել կուրսորը էկրանին:
  • blink() և noBlink() - կուրսորը թարթում է/չի թարթում (եթե դրա ցուցադրումը նախկինում միացված է եղել):
  • display() և noDisplay() - թույլ է տալիս միացնել/անջատել ցուցադրումը:
  • scrollDisplayLeft() և scrollDisplayRight() - ոլորում է էկրանը մեկ նիշ ձախ/աջ:
  • autoscroll() և noAutoscroll() - թույլ է տալիս միացնել/անջատել autoscroll ռեժիմը: Այս ռեժիմում յուրաքանչյուր նոր նիշ գրվում է նույն տեղում՝ փոխարինելով էկրանին նախկինում գրվածին:
  • leftToRight() և rightToLeft() - Սահմանում է ցուցադրվող տեքստի ուղղությունը՝ ձախից աջ կամ աջից ձախ:
  • createChar(ch, bitmap) - Ստեղծում է ch կոդով նիշ (0 - 7), օգտագործելով bitmap bitmap-ի զանգված՝ սև և սպիտակ կետեր ստեղծելու համար:

Այլընտրանքային գրադարան i2c էկրանի հետ աշխատելու համար

Որոշ դեպքերում, երբ օգտագործվում է նշված գրադարանը PCF8574 կարգավորիչներով հագեցած սարքերով, կարող են սխալներ առաջանալ: Այս դեպքում LiquidCrystal_PCF8574.h գրադարանը կարող է առաջարկվել որպես այլընտրանք: Այն ընդլայնում է LiquidCrystal_I2C-ը, ուստի դրա օգտագործման հետ կապված խնդիրներ չպետք է լինեն:

i2c LCD էկրանի միացման խնդիրներ

Եթե ​​ուրվագիծը վերբեռնելուց հետո էկրանին ոչինչ չեք տեսնում, փորձեք հետևյալ քայլերը.

Նախ, դուք կարող եք ավելացնել կամ նվազեցնել մոնիտորի հակադրությունը: Հաճախ կերպարները պարզապես չեն երևում հակադրության և լուսային ռեժիմի պատճառով:

Եթե ​​դա չի օգնում, ապա ստուգեք կոնտակտների ճիշտ կապը, արդյոք հետին լույսը միացված է: Եթե ​​դուք օգտագործել եք առանձին i2c ադապտեր, ապա նորից ստուգեք կոնտակտների զոդման որակը։

Էկրանի վրա տեքստի բացակայության մեկ այլ ընդհանուր պատճառ կարող է լինել սխալ i2c հասցեն: Նախ փորձեք փոխել սարքի հասցեն էսքիզում 0x27 0x20 կամ 0x3F: Տարբեր արտադրողներ կարող են ունենալ տարբեր լռելյայն հասցեներ: Եթե ​​դա չօգնի, կարող եք գործարկել i2c սկաների ուրվագիծը, որը սկանավորում է բոլոր միացված սարքերը և կոպիտ ուժով որոշում դրանց հասցեն: i2c սկաների օրինակ:

Եթե ​​էկրանը դեռ չի աշխատում, փորձեք անջատել ադապտերը և միացնել LCD-ը սովորական եղանակով:

Եզրակացություն

Այս հոդվածում մենք լուսաբանել ենք LCD էկրանի օգտագործման հիմնական խնդիրները Arduino-ի բարդ նախագծերում, երբ մեզ անհրաժեշտ է պահել տախտակի վրա անվճար կապում: Պարզ և էժան i2c ադապտերը թույլ կտա միացնել 1602 LCD էկրան՝ զբաղեցնելով ընդամենը 2 անալոգային կապ: Շատ իրավիճակներում դա կարող է շատ կարևոր լինել: Հարմարավետության գինը լրացուցիչ մոդուլի օգտագործման անհրաժեշտությունն է՝ փոխարկիչ և գրադարան: Մեր կարծիքով, սա բարձր գին չէ հարմարության համար, և մենք խորհուրդ ենք տալիս օգտագործել այս հնարավորությունը նախագծերում:

ՀԱՐԱԿԻՑ ՀՈԴՎԱԾՆԵՐ