Յուրաքանչյուր ռադիոսիրող, որոշակի թվով պարզ տնական նախագծերից հետո, հասնում է սենսորների և կոճակների միջոցով ինչ-որ մեծ բան կառուցելու նպատակին: Ի վերջո, շատ ավելի հետաքրքիր է տվյալների ցուցադրումը էկրանի վրա, քան նավահանգստի մոնիտորին: Բայց հետո հարց է առաջանում՝ ո՞ր ցուցադրումն ընտրել։ Իսկ ընդհանրապես, ինչպե՞ս միացնել այն, ի՞նչ է անհրաժեշտ միանալու համար։ Այս հարցերի պատասխանները կքննարկվեն այս հոդվածում:

LCD 1602

Ցուցադրման բազմաթիվ տարբերակների շարքում ես կցանկանայի հատուկ նշել LCD1602 էկրանը, որը հիմնված է HD4478 կարգավորիչի վրա: Այս էկրանը հասանելի է երկու գույնով՝ սպիտակ տառեր կապույտ ֆոնի վրա, սև տառեր դեղին ֆոնի վրա: LCD 1602-ը Arduino-ին միացնելը նույնպես որևէ խնդիր չի առաջացնի, քանի որ կա ներկառուցված գրադարան և կարիք չկա որևէ լրացուցիչ բան ներբեռնելու: Ցուցասարքերը տարբերվում են ոչ միայն գնով, այլև չափսերով։ Հաճախ ռադիոսիրողները օգտագործում են 16 x 2, այսինքն, 2 տող 16 նիշից: Բայց կա նաև 20 x 4, որտեղ կա 20 նիշից բաղկացած 4 տող: Չափերը և գույնը որևէ դեր չեն խաղում LCD 1602 էկրանը Arduno-ին միացնելու համար, դրանք միացված են նույն ձևով: Դիտման անկյունը 35 աստիճան է, էկրանի արձագանքման ժամանակը 250 ms: Այն կարող է աշխատել -20-ից մինչև 70 աստիճան ջերմաստիճանում: Գործողության ընթացքում այն ​​օգտագործում է 4 մԱ էկրանի համար, իսկ 120 մԱ՝ հետին լույսի համար:

Որտեղ է այն օգտագործվում:

Այս ցուցադրումը տարածված է ոչ միայն ռադիոսիրողների, այլև խոշոր արտադրողների շրջանում: Օրինակ, տպիչներն ու սուրճի մեքենաները նույնպես օգտագործում են LCD1602: Դա պայմանավորված է իր ցածր գնով, այս ցուցադրումն արժե 200-300 ռուբլի չինական կայքերում: Արժե այնտեղ գնել, քանի որ մեր խանութներում այս ցուցադրման նշումները շատ բարձր են:

Միացում Arduino-ին

LCD 1602-ը Arduino Nano-ին և Uno-ին միացնելը չի ​​տարբերվում: Էկրանի հետ կարող եք աշխատել երկու ռեժիմով՝ 4 բիթ և 8։ 8 բիթով աշխատելիս օգտագործվում են և՛ ցածրակարգի, և՛ բարձր կարգի բիթերը, իսկ 4 բիթով՝ միայն ցածրակարգը։ 8-բիթով աշխատելը առանձնահատուկ իմաստ չունի, քանի որ այն կավելացնի ևս 4 կոնտակտ միացման համար, ինչը նպատակահարմար չէ, քանի որ արագությունը ավելի բարձր չի լինի, ցուցադրման թարմացումների սահմանաչափը վայրկյանում 10 անգամ է: Ընդհանուր առմամբ, lcd 1602-ը Arduino-ին միացնելու համար շատ լարեր են օգտագործվում, ինչը որոշակի անհարմարություններ է առաջացնում, բայց կան հատուկ վահաններ, բայց դրա մասին ավելի ուշ: Լուսանկարը ցույց է տալիս էկրանի միացումը Arduino Uno-ին.

Նմուշ կոդ.

#ներառում // Ավելացնել անհրաժեշտ LiquidCrystal գրադարանի lcd(7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) void setup())( lcd.begin(16, 2); // Սահմանել էկրանի չափը lcd.setCursor(0, 0); // Սահմանել կուրսորը սկզբին 1 տող lcd.print("Բարև, աշխարհ!" // Տպեք տեքստը lcd.setCursor(0, 1) // Տպել տեքստը ) void loop ()( )

Ի՞նչ է անում կոդը: Առաջին քայլը գրադարանը միացնելն է էկրանի հետ աշխատելու համար: Ինչպես նշվեց վերևում, այս գրադարանն արդեն ներառված է Arduino IDE-ում և կարիք չունի լրացուցիչ ներբեռնման և տեղադրման: Հաջորդը որոշվում են կոնտակտները, որոնք միացված են կապումներին՝ համապատասխանաբար RS, E, DB4, DB5, DB6, DB7: Այնուհետև սահմանվում է էկրանի չափը: Քանի որ մենք աշխատում ենք 16 նիշ և 2 տող ունեցող տարբերակի հետ, գրում ենք հետևյալ արժեքները. Մենք տեղադրում ենք կուրսորը առաջին տողի սկզբում և ցուցադրում մեր առաջին տեքստը Hello World: Հաջորդը, կուրսորը տեղադրեք երկրորդ տողի վրա և ցուցադրեք կայքի անունը: Այսքանը: Դիտարկվել է 1602 LCD-ի միացումը Arduino Uno-ին:

Ի՞նչ է I2C-ը և ինչու է այն անհրաժեշտ:

Ինչպես նշվեց վերևում, էկրանը միացնելը շատ կոնտակտներ է պահանջում: Օրինակ, մի քանի սենսորների և LCD էկրանի հետ աշխատելիս 1602 քորոցը կարող է պարզապես բավարար չլինել: Հաճախ ռադիոսիրողները օգտագործում են Uno կամ Nano տարբերակները, որոնք շատ կոնտակտներ չունեն։ Հետո մարդիկ եկան հատուկ վահաններով: Օրինակ, I2C. Այն թույլ է տալիս միացնել էկրանը միայն 4 կապում: Սա երկու անգամ ավելի է։ I2C մոդուլը վաճառվում է և՛ առանձին, որտեղ անհրաժեշտ է զոդել այն ինքներդ, և՛ արդեն զոդված է LCD 1602 էկրանին:

Միացում՝ օգտագործելով I2C մոդուլը

LCD 1602-ը Arduino Nano-ին I2C-ով միացնելը քիչ տեղ է զբաղեցնում, ընդամենը 4 պին` հող, հզորություն և 2 տվյալների ելք: Մենք հոսանքն ու հողը միացնում ենք Arduino-ի համապատասխանաբար 5V-ին և GND-ին: Մենք միացնում ենք մնացած երկու կոնտակտները՝ SCL և SDA ցանկացած անալոգային կապին: Լուսանկարում դուք կարող եք տեսնել lcd 1602-ը arduino-ին I2C մոդուլով միացնելու օրինակ.

Ծրագրի կոդը

Եթե ​​առանց մոդուլի դիսփլեյի հետ աշխատելու համար անհրաժեշտ էր օգտագործել միայն մեկ գրադարան, ապա մոդուլի հետ աշխատելու համար անհրաժեշտ է երկու գրադարան։ Դրանցից մեկն արդեն ներառված է Arduino IDE - Wire-ում: Մեկ այլ գրադարան՝ LiquidCrystal I2C-ը, պետք է առանձին ներբեռնվի և տեղադրվի: Գրադարանը Arduino-ում տեղադրելու համար ներբեռնված արխիվի բովանդակությունը պետք է բեռնվի արմատային գրադարանների պանակում: Ծրագրի կոդ օրինակ՝ օգտագործելով I2C.

#ներառում #ներառում LiquidCrystal_I2C LCD (0x27,16,2); // Սահմանեք ցուցադրման void setup() ( 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	0	0	1	0
0	0	0	0	1
1	1	0	0	1
0	0	0	0	1
1	1	0	0	1
0	0	0	0	1
0	0	0	1	0
0	0	0	0	0

Եթե ​​0 - այնտեղ ոչինչ չկա, եթե 1 - սա ներկված տարածք է: Վերևի օրինակում կարող եք տեսնել «ժպտացող ժպտացող» խորհրդանիշի ստեղծումը: Օգտագործելով օրինակ ծրագիր Arduino-ում, այն կունենա հետևյալ տեսքը.

#ներառում #ներառում // Ավելացնել անհրաժեշտ գրադարանը // Ժպիտի խորհրդանիշի բիթային դիմակ բայթ ժպիտ = ( B00010, B00001, B11001, B00001, B11001, B00001, B00010, ); LiquidCrystal LCD (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) void setup())( lcd.begin(16, 2); // Սահմանեք էկրանի չափը lcd.createChar(1, ժպտացեք); // Ստեղծեք նիշերի համարը 1 lcd.setCursor(0, 0) Կուրսորը դրեք 1-ին տողի սկզբում lcd.print("\1") - "\1" ) void loop(); ) ( )

Ինչպես տեսնում եք, bitmask-ը ստեղծվել է նույնը, ինչ աղյուսակը: Ստեղծվելուց հետո այն կարող է ցուցադրվել որպես փոփոխական էկրանին: Հիշեք, որ դուք կարող եք պահել միայն 7 նիշ հիշողության մեջ: Սկզբունքորեն սա բավական է։ Օրինակ, եթե ձեզ անհրաժեշտ է ցույց տալ աստիճանի նշան:

Խնդիրներ, որոնց դեպքում էկրանը կարող է չաշխատել

Կան դեպքեր, երբ էկրանը չի աշխատում: Օրինակ՝ միանում է, բայց նիշեր չի ցուցադրում։ Կամ ընդհանրապես չի միանում։ Նախ, ստուգեք, արդյոք դուք ճիշտ եք միացրել կապում: Եթե ​​դուք օգտագործել եք LCD 1202 միացում Arduino-ին առանց I2C-ի, ապա շատ հեշտ է խճճվել լարերի մեջ, ինչը կարող է հանգեցնել էկրանի սխալ աշխատանքին: Դուք նաև պետք է համոզվեք, որ էկրանի կոնտրաստը մեծանում է, քանի որ նվազագույն հակադրության դեպքում նույնիսկ տեսանելի չէ LCD 1602-ը միացված է, թե ոչ: Եթե ​​դա չի օգնում, ապա գուցե խնդիրը կարող է ընկած լինել կոնտակտների զոդման մեջ, սա այն դեպքում, երբ օգտագործում եք I2C մոդուլը: Մեկ այլ ընդհանուր պատճառ, թե ինչու էկրանը կարող է չաշխատել, I2C հասցեի սխալ կարգավորումն է: Փաստն այն է, որ կան շատ արտադրողներ, և նրանք կարող են տեղադրել այլ հասցե, դուք պետք է այն ուղղեք այստեղ.

LiquidCrystal_I2C LCD (0x27,16,2);

Փակագծերում դուք կարող եք տեսնել երկու արժեք՝ 0x27 և 16.2 (16.2-ը ցուցադրման չափն է, իսկ 0x27-ը՝ I2C հասցեն): Այս արժեքների փոխարեն կարող եք փորձել սահմանել 0x37 կամ 0x3F: Դե, մեկ այլ պատճառ պարզապես անսարք LCD 1602-ն է: Հաշվի առնելով, որ Arduino-ի համար գրեթե ամեն ինչ արտադրված է Չինաստանում, դուք չեք կարող 100% վստահ լինել, որ գնված ապրանքը թերի չէ:

LCD 1602-ի առավելություններն ու թերությունները

Եկեք նայենք LCD 1602 էկրանի դրական և բացասական կողմերին:

• Գին. Այս մոդուլը կարելի է ձեռք բերել շատ մատչելի գնով չինական խանութներից։ Գինը 200-300 ռուբլի է: Երբեմն այն նույնիսկ վաճառվում է I2C մոդուլի հետ միասին։
• Հեշտ է միացնել: Հավանաբար այս օրերին ոչ ոք չի միացնում LCD 1602 առանց I2C: Իսկ այս մոդուլով միացումը տեւում է ընդամենը 4 կոնտակտ, լարերի «ցանցեր» չեն լինի։
• Ծրագրավորում. Պատրաստի գրադարանների շնորհիվ այս մոդուլի հետ աշխատելը հեշտ է, բոլոր գործառույթներն արդեն գրված են. Եվ եթե ձեզ անհրաժեշտ է ավելացնել ձեր սեփական խորհրդանիշը, ապա դա տևում է ընդամենը մի քանի րոպե:

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

Այս հոդվածը քննարկել է 1602-ը Arduino-ին միացնելը, ինչպես նաև տրամադրել է այս էկրանի հետ աշխատելու ծրագրերի օրինակներ: Այն իսկապես լավագույններից մեկն է իր կատեգորիայում, իզուր չէ, որ հազարավոր ռադիոսիրողներ ընտրում են այն իրենց նախագծերի համար:

1602 չափսերի LCD էկրանները, որոնք հիմնված են HD44780 կարգավորիչի վրա, ամենապարզ, մատչելի և հանրաճանաչ էկրաններից են տարբեր էլեկտրոնային սարքերի մշակման համար: Այն կարելի է գտնել ինչպես ծնկի վրա հավաքված սարքերում, այնպես էլ արդյունաբերական սարքերում, ինչպիսիք են, օրինակ, սուրճի մեքենաները։ Ամենատարածված Arduino-ի թեմաներով մոդուլներն ու վահանները, ինչպիսիք են և հավաքվում են այս ցուցադրման հիման վրա:

Այս հոդվածում մենք ձեզ կասենք, թե ինչպես միացնել այն Arduino-ին և ցուցադրել տեղեկատվությունը:

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

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

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

Այս դիսփլեյներն ունեն երկու ձևավորում՝ դեղին հետին լուսավորություն սև տառերով կամ, որն ավելի տարածված է, կապույտ հետին լույս՝ սպիտակ տառերով:

HD44780 կարգավորիչի էկրանների չափերը կարող են տարբեր լինել, բայց դրանք կկառավարվեն նույն կերպ: Ամենատարածված չափերն են 16x02 (այսինքն՝ 16 նիշ երկու տողում) կամ 20x04: Իրենց սիմվոլների լուծումը 5x8 պիքսել է:

Ցուցասարքերից շատերը չեն աջակցում կիրիլիցա այբուբենին միայն այն ցուցադրում են, որոնց վրա նշված է CTK: Բայց մենք կարող ենք փորձել մասնակիորեն լուծել այս խնդիրը (շարունակությունը՝ հոդվածում)։

Ցուցադրման արդյունքները.

Ցուցասարքը միացման համար ունի 16 պին միակցիչ: Տախտակի հետևի մասում նշվում են քորոցները:

1 (VSS) - Կարգավորիչի էլեկտրամատակարարում (-)
2 (VDD) - կարգավորիչի էլեկտրամատակարարում (+)
3 (VO) - Կոնտրաստային հսկիչ փին
4 (RS) - Գրանցվել ընտրել
5 (R/W) - կարդալ/գրել (գրելու ռեժիմ, երբ միացված է գետնին)
6 (E) - Միացնել (strobe on the down)
7-10 (DB0-DB3) - 8-բիթանոց ինտերֆեյսի ցածր կարգի բիթեր
11-14 (DB4-DB7) - ինտերֆեյսի բարձր կարգի բիթ
15 (A) - Անոդ (+) հետին լույսի սնուցման աղբյուր
16 (K) - կաթոդ (-) հետևի լույսի սնուցման աղբյուր

Ինքնաթեստավորման ռեժիմ.

Նախքան տեղեկատվությունը միացնելու և ցուցադրելու փորձը, լավ կլինի պարզել՝ էկրանն աշխատում է, թե ոչ: Դա անելու համար դուք պետք է լարում կիրառեք հենց կարգավորիչին ( VSS և VDD), միացրեք հետևի լույսը ( Ա և Կ), ինչպես նաև կարգավորել հակադրությունը:

Հակադրությունը կարգավորելու համար օգտագործեք 10 կՕմ պոտենցիոմետր: Կարևոր չէ, թե դա ինչ ձևով կլինի։ +5V և GND մատակարարվում են արտաքին ոտքերին, կենտրոնական ոտքը միացված է ելքին Վ.Օ.

Շղթայի վրա հոսանք կիրառելուց հետո անհրաժեշտ է հասնել ճիշտ հակադրության, եթե այն ճիշտ չի դրված, ապա էկրանին ոչինչ չի ցուցադրվի. Հակադրությունը կարգավորելու համար խաղացեք պոտենցիոմետրի հետ:

Եթե ​​սխեման ճիշտ հավաքված է, և հակադրությունը ճիշտ է կարգավորվում, վերին գիծը պետք է լցված լինի էկրանին ուղղանկյուններով:

Տեղեկատվության ելք.

LiquidCrystal.h գրադարանը, որը ներկառուցված է Arduino IDE-ում, օգտագործվում է էկրանը գործարկելու համար:

Գրադարանի ֆունկցիոնալությունը

//Աշխատանք կուրսորի հետ lcd.setCursor (0, 0); // Սահմանել կուրսորը (բջջի համարը, տողը) lcd.home(); // Կուրսորը դրեք զրո (0, 0) lcd.cursor(); // Միացնել կուրսորի տեսանելիությունը (ընդգծել) lcd.noCursor(); // Հեռացնել կուրսորի տեսանելիությունը (ընդգծել) lcd.blink(); // Միացնել կուրսորի թարթումը (կուրսորը 5x8) lcd.noBlink(); // Անջատել կուրսորի թարթումը (կուրսորը 5x8) //Տեղեկատվության ելք lcd.print ("կայք"); // Տեղեկատվության ելք lcd.clear(); // Մաքրել էկրանը, (ջնջել բոլոր տվյալները) կուրսորը դնել զրո lcd.rightToLeft(); // Ձայնագրումը կատարվում է աջից ձախ lcd.leftToRight(); // Գրելը կատարվում է ձախից աջ lcd.scrollDisplayRight(); // Ցուցասարքի ամեն ինչ մեկ նիշ տեղափոխեք աջ lcd.scrollDisplayLeft(); // Ցուցասարքի ամեն ինչ մեկ նիշ տեղափոխեք ձախ //Լրտեսների համար օգտակար տեղեկատվություն :) lcd.noDisplay(); // Էկրանի վրա տեղեկատվությունը դառնում է անտեսանելի, տվյալները չեն ջնջվում // եթե այս ֆունկցիայի ակտիվացման պահին ոչինչ չի ցուցադրվում, ապա lcd.display(); // Display() ֆունկցիան կանչելիս ամբողջ տեղեկատվությունը, որը եղել է

Ցուցադրումն ինքնին կարող է գործել երկու ռեժիմով.

8-բիթանոց ռեժիմ. դրա համար օգտագործվում են ինչպես ցածր, այնպես էլ բարձր բիթ (BB0-DB7)

4-բիթանոց ռեժիմ - դրա համար օգտագործվում են միայն ամենաքիչ կարևոր բիթերը (BB4-DB7)

Այս էկրանի վրա 8 բիթ ռեժիմ օգտագործելը խորհուրդ չի տրվում: Դրա շահագործումը պահանջում է ևս 4 ոտք, և գործնականում արագություն չկա, քանի որ Այս էկրանի թարմացման արագությունը սահմանափակ է< 10раз в секунду.

Տեքստ թողարկելու համար դուք պետք է միացնեք RS, E, DB4, DB5, DB6, DB7 կապիչները կարգավորիչի կապին: Նրանք կարող են միացված լինել ցանկացած Arduino կապին, գլխավորը կոդում ճիշտ հաջորդականություն սահմանելն է։

Նմուշ կոդ.

#ներառում LiquidCrystal LCD (7, 6, 5, 4, 3, 2); անվավեր կարգավորում()(lcd.begin(16, 2); // Սահմանեք էկրանի չափը lcd.setCursor (0, 0); lcd.print («Բարև, աշխարհ»); // Ցուցադրել տեքստը lcd.setCursor (0, 1); // Կուրսորը դրեք 2-րդ տողի սկզբին lcd.print ("կայք"); // Արդյունք տեքստ ) void հանգույց (){ }

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

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

Խնդիր չկա, անհրաժեշտ խորհրդանիշը կարելի է ձեռքով ստեղծել (ընդհանուր մինչև 7 նշան): Մեր դիտարկվող էկրանների բջիջն ունի 5x8 պիքսել թույլատրություն: Սիմվոլ ստեղծելու խնդիրը միայն մի քիչ դիմակ գրելն է և դրա մեջ կետերը տեղադրելը այն վայրերում, որտեղ կետերը պետք է լուսավորվեն, իսկ զրոյականները, որտեղ դրանք չպետք է լինեն:

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

Նմուշ կոդ

//Փորձարկվել է Arduino IDE 1.0.5-ի վրա#ներառում #ներառում // Ավելացնել անհրաժեշտ գրադարանը // Ժպիտի խորհրդանիշի բիտդիմակբայթ ժպիտ = ( B00010, B00001, B11001, B00001, B11001, B00001, B00010, ); LiquidCrystal LCD (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7)անվավեր կարգավորում()(lcd.begin(16, 2); // Սահմանեք էկրանի չափը lcd.createChar (1, ժպտացեք); // Ստեղծեք թիվ 1 խորհրդանիշը lcd.setCursor (0, 0); // Կուրսորը դրեք 1 տողի սկզբի վրա lcd.print ("\1"); // Ցուցադրել ժպտացող դեմք (նիշ թիվ 1) - «\1») անվավեր հանգույց (){ }

Բոնուս

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

• իգորկա

  նիշերի գեներատոր, ինչպես վերևում,
  Ես դա արեցի, քանի որ թույլ չէի)

Այս անգամ ես ուզում եմ ձեզ պատմել, թե ինչպես կարելի է Nokia 1202 բջջային հեռախոսից էկրանը միացնել Atmega8 միկրոկառավարիչին: Մենք ծրագրավորում ենք CodeVision միջավայրում։ Ես կարող եմ սխալվել այստեղ և այնտեղ: Շատ չանցավ, որ ես հասկացա, թե ինչն էր: Ես ծրագրավորման փորձ չունեմ և գրադարան չեմ գրել էկրանի հետ աշխատելու համար։ Դրանք պատճենվել են համացանցում մեկ նախագծից: Այնտեղ գրված են բոլոր անհրաժեշտ գործառույթները և կա 5*8 տառատեսակ լատինատառ և կիրիլիցայով։ Կան նաև մի քանի նիշ 12*16 և 24*32, որոնք գրադարանների հեղինակն օգտագործել է իր սարքում։ Եթե ​​դրանք հեռացնեք, ապա 5*8 տառատեսակը կխլի մոտ 700 բայթ միկրոկոնտրոլերի ֆլեշ: Հետևաբար, նախագծի համար նախատեսված միկրոկառավարիչը պետք է «ավելի ճարպ» վերցվի, իմ դեպքում ես օգտագործել եմ Atmega8. Բավականին բավական է։ Բոլոր ֆայլերը՝ աղբյուրներ, գրադարան և այլն, .

Ցուցանիշի միացման դիագրամ

LCD էկրանը MK-ին միացնելու սխեմատիկ դիագրամ

Ես գծեցի կապի դիագրամ: Էկրանի սնուցման համար անհրաժեշտ է 3,3 Վ լարում: Եթե ​​միկրոկառավարիչը սնուցում եք 5 Վ-ից, ապա տեղադրեք ռեզիստորի բաժանարարներ և միկրոշրջան 78L33. Եթե ​​ամբողջ սխեման սնուցվում է 3,3 Վ-ից, ապա դիմադրիչների բաժանարարներն անհրաժեշտ չեն: Թվում է, որ Atmega8A-ն կարող է աշխատել 3.3 Վ-ից, պայմանով, որ հաճախականությունը 8 ՄՀց-ից բարձր չէ: Անձամբ ես չեմ փորձել: Ես ամեն ինչ հավաքել եմ վրիպազերծման տախտակի վրա, որը սնուցվում է 5 Վ-ով: Ոչ մի դեպքում չպետք է մեծ հզորության էլեկտրոլիտ դնել հենց էկրանի դիմաց: Գործողության հենց սկզբում վերահսկիչը էկրանին ուղարկում է սկզբնավորման հրամաններ: Կոնդենսատորը լիցքավորելու համար ժամանակ է պահանջվում: Մինչ այն լիցքավորվում է, և էկրանը սկսում է աշխատել, որոշ ժամանակ կանցնի, և այն չի ստանա սկզբնավորման հրաման: Իհարկե, դրանք միլիվայրկյաններ են, բայց այս դեպքում էֆեկտը նկատելի է։

Ցուցադրել փորագրման դիագրամ

Nokia 1202 էկրանն ունի 9-բիթանոց SPI ինտերֆեյս: Մեր ընտրած միկրոկոնտրոլերը այս շքեղությունը չունի։ Հետևաբար, էկրանի հետ շփվելու համար մենք օգտագործում ենք ոչ թե ապարատային, այլ ծրագրային ապահովման SPI, այսպես ասած, «անտեղի», ես ձեզ չեմ ասի, թե ինչպես ստեղծել նոր նախագծեր CodeVision-ում, ես միայն կասեմ PORTB կապերը պետք է կազմաձևվեն որպես ելք: Ծրագրի կարգավորումներում դուք պետք է նշեք «»: Պահպանեք գլոբալ հաստատունները FLASH հիշողության մեջ« Այս գործողությունը անհրաժեշտ է, որպեսզի տառատեսակների զանգվածները և մեր պատկերները պահվեն ֆլեշում:

Այսպիսով, մենք ստեղծեցինք նախագիծը: Մենք ընտրեցինք միկրոկոնտրոլեր, սահմանեցինք ժամացույցի հաճախականությունը և կազմաձևեցինք նախագիծը: Ի՞նչ է հաջորդը: Եվ այնուհետև անհրաժեշտ է ավելացնել գրադարաններ էկրանի հետ աշխատելու և հետաձգելու գրադարանները: Բացեք արխիվը: Այնտեղ երկու ֆայլ կա։ Նրանք պետք է պատճենվեն հատուկ թղթապանակներում: Հուսով եմ, որ դուք տեղադրել եք CodeVision-ը անմիջապես C:\ սկավառակի վրա: Եթե ​​այո, ապա պատճենեք ֆայլերը համապատասխան ուղիներով.

C:\cvavreval\inc 1100.inc ֆայլի համար և
C:\cvavreval\lib 1100.h ֆայլի համար:

Նաև ուզում եմ ասել, որ ֆայլում կարող է փոխվել միկրոկոնտրոլերի փիների նշանակումը 1100.ժ. Այնուհետեւ կապի դիագրամը կփոխվի: Եկեք սկսենք կոդավորումը: Եկեք ուղղակի ցուցադրենք էկրանի վրա 5*8 հիմնական տառատեսակով որոշ մակագրություն: Հենց սկզբում կավելացնենք գրադարաններ։

#ներառում< 1100.h>// ցուցադրել գրադարան
#ներառում // հետաձգման գրադարան

Հենց ներքևում, մինչև հիմնական while(1)() հանգույցը, մենք նախաստորագրում ենք էկրանը և մաքրում այն:

lcd_init (); // ցուցադրման սկզբնավորում
lcd_clear(); // մաքրել էկրանը

Մենք կտեղադրենք նաև մեր մակագրությունը հիմնական ցիկլից առաջ։ Թույլ տվեք, որ կարգավորիչը նախ ցուցադրի հաղորդագրությունը էկրանին, այնուհետև պտտվի հիմնական օղակում: Մենք գրում ենք սա.

print_string ("Արտադրել մակագրությունը",5,0);
print_string ("Ինչ ուզում ենք",0,1);
print_string ("BUCKER",10,2);

Կարծում եմ՝ այստեղ ամեն ինչ պարզ է։ Առաջին նիշը էկրանի x-կոորդինատն է: Այն կարող է վերցնել 0-ից մինչև 96 արժեք: Երկրորդը տող է: 0-ից 7-ն է։ Սկզբունքորեն 8 ու կես տող է տեղավորվում, բայց կես տող չենք կարդա։ Կազմում ենք և ֆլեշում։ Եկեք նայենք արդյունքին: Կարող եք նաև տեղադրել Proteus-ը և փորձարկել այն: Կարգավորիչը կարող է կազմաձևվել այնպես, որ աշխատի ներքին գեներատորից նախագծում նշված հաճախականությամբ 64 մվ մեկնարկային ուշացումով: Կազմված նախագծով ավելացնում եմ արխիվ։ Հաճախականությունը 8 ՄՀց:

Բայց ինչպես սկզբում արդեն գրել եմ, գրադարանում կան նաև այլ նշաններ։ Ճիշտ է, չկան տառեր, կան միայն թվեր։ Հիմա մի փոքր բարդացնենք խնդիրը։ Թող մակագրությունը իներտ չլինի, այլ փոխվի։ Ենթադրենք՝ հաշվում է 0-ից 9-ը՝ 1 վայրկյան ընդմիջումով։ Երբ այն հասնի 9-ի, այն կվերակայվի զրոյի և նորից կսկսի: Վերցնենք մեծ թվեր, որոնք չափում են 24*32: Դե, եկեք սկսենք: Կարող եք վերցնել նախորդ նախագիծը և ջնջել «print_string» երեք տողերը, գրադարանները ավելացնելուց անմիջապես հետո հայտարարենք որոշակի գլոբալ փոփոխական մ.

char m = 0;

Դուք կարող եք պարզապես գրել.

Այս դեպքում նրան ավտոմատ կերպով վերագրվելու է 0 արժեքը: Հիմնական օղակում մենք գրում ենք սա.

char_24_32 (m,35,2); //խորհրդանիշի ելքային ֆունկցիա 24*32
delay_ms (1000); // սպասել 1 վայրկյան
m ++; // m փոփոխականին ավելացնել 1
if(m>9)m=0; // Վիճակ. Եթե ​​m փոփոխականը մեծ է 9-ից, ապա m-ը հավասար է 0-ի:

Ես կարճ տեսանյութ եմ պատրաստել ծրագրի աշխատանքի մասին

Ես կփորձեմ ձեզ պատմել, թե ինչպես նկարել նկարներ և ցուցադրել դրանք ցուցադրվող էկրանին: Ինչպես ստեղծել զանգվածներ և գործառույթներ՝ դրանք ելքի համար և ինչպես շրջել պատկերը: Գրադարանները փոխառվել են cxem.net կայքից։ Պատրաստված նյութը Բուզեր.

Քննարկեք ԷԿՍՊԼԵՍԸ ՄԻԿՐՈԿՐՈՂԻՐԻՆ ՄԻԱՑՆԵԼՈՎ հոդվածը

Ո՞րն է մեծ թվով էլեկտրոնային սարքերի անբաժանելի մասը: Իհարկե, նշման միջոցներ և տվյալների գրաֆիկական ելք: Օգտագործողի համար միշտ ավելի հարմար և հաճելի է, երբ «խելացի տուփի» արդյունքը տեսանելի է: Հետևաբար, այսօր մենք էկրանը միացնելու ենք STM32-ին՝ տեքստ և թվեր ցուցադրելու համար: Մեր փորձերի հերոսը կլինի Winstar-ի բավականին հայտնի ցուցադրությունը: Ի դեպ, մեկնաբանություններում մի կարևոր պարզաբանում հայտնվեց, որ մեթոդաբանությունը հիմնականում նույնն է բոլոր ցուցադրումների համար՝ հիմնված. HD44780.Շնորհակալություն JekaKey-ին կարևոր հավելման համար)

Նախ, էկրանը պետք է միացված լինի կարգավորիչին: Ներբեռնեք տվյալների աղյուսակը և փնտրեք WH1602 մատնահետքը: Նայեք այստեղ.

Ինչպես գիտեք, ցուցադրել WH1602ունի 16 կապում: Եկեք նայենք յուրաքանչյուրին առանձին...

Pins Vss, Vdd և K պետք է միացված լինեն գետնին և հոսանքին, այսինքն, ճիշտ այնպես, ինչպես նշված է աղյուսակում, չկան անակնկալներ և նույնիսկ քննարկելու բան)

Կոնտրաստը կարգավորելու համար օգտագործվում է 3-րդ փին, եթե այնտեղ +5V կիրառենք, բացարձակապես ոչինչ չենք տեսնի, իսկ եթե սեղմենք գետնին կարճ միացնենք, մենք կհիանանք սև քառակուսիների երկու շարքով 😉 Բնականաբար, սա մեզ չի սազում։ , ուստի մենք պետք է այնտեղ կախենք պոտենցիոմետր (ռեզիստոր)՝ փոփոխական դիմադրությամբ)՝ կոնտրաստը կարգավորելու համար։ Նիշերի լավագույն տեսանելիությունը տրամադրվում է 0,5-0,7 Վ լարման այս ցուցադրման պինդում:

RS քորոցն արդեն մի փին է, որը մենք ինքներս ենք կառավարելու՝ օգտագործելով միկրոկոնտրոլեր: Ցածր լարման մակարդակը (0) այս փինում նշանակում է, որ այժմ կհետևի հրաման, իսկ բարձր մակարդակը (1) նշանակում է, որ այժմ կլինեն տվյալներ, որոնք պետք է գրվեն ցուցադրման հիշողության մեջ:

Pin R/W - այստեղ պարզ է, կա՛մ մենք կարդում ենք տվյալները (օրինակ՝ ցուցադրում ենք զբաղված դրոշը), այս դեպքում այս փինում կա 1, կա՛մ մենք գրում ենք հրամանը/տվյալները էկրանին, ապա այստեղ ունենք 0:

DB7 – DB0 – տվյալների ավտոբուս, և դրանով ամեն ինչ ասված է)

Pin E-ն այսպես կոչված Enable ազդանշանն է: Ահա թե ինչի համար է նա պետք։ Էկրանի հետ աշխատելու համար՝ տվյալների գրանցում կամ հրաման թողարկելու համար, մենք պետք է դրական իմպուլս թողարկենք այս քորոցին: Այսինքն, ընթացակարգը կունենա հետևյալ տեսքը.

1. RS, R/W, DB7 - DB0 կապումներում՝ մեր հրամանին համապատասխանող անհրաժեշտ ազդանշանները:
2. Մենք մատակարարում ենք մեկը կապելու E.
3. Ժդեմս (ըստ տվյալների թերթիկի՝ առնվազն 150 նվ)
4. Մենք կիրառում ենք ցածր մակարդակ (0) E-ի ամրացման համար:

Դուք պետք է միացնեք 4,2 Վ A/Vee ոտքի վրա էկրանի հետին լույսը միացնելու համար:

Ահա թե ինչպես է տեղի ունենում շփումը WH1602 էկրանի հետ։

Մենք պարզել ենք WH1602-ի միացումը, բայց նախքան օրինակին անցնելը, եկեք տեսնենք, թե մեր էկրանն ընդհանուր առմամբ ինչ հրամաններ է հասկանում: Դա անելու համար մենք մտնում ենք տվյալների թերթիկ և գտնում ենք հետաքրքիր աղյուսակ.

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

Մենք զրոներ ենք կիրառում RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 կապում, իսկ մեկ՝ DB0 կապում: Կատարված է: Ճիշտ է, մեկը պինդ E-ի վրա, հետո մի քիչ սպասեք և E-ն նորից իջեցրեք զրոյի: Վերջ, էկրանը մաքրված է 😉 Հաջորդ հրամանը կատարելուց անմիջապես առաջ պետք է դադար անել, որը նշված է տվյալների աղյուսակում յուրաքանչյուր հրամանի համար: Ավելի արդյունավետ կլինի զբաղված դրոշի հարցում անելը, հենց որ այն վերականգնվի 0-ի, կարող եք շարունակել աշխատել: Այս դրոշը կարդալու համար նույնպես հատուկ հրաման կա, ուստի սրանով ամեն ինչ պարզ է) Անցնենք առաջ...

Եվ, փաստորեն, ամեն ինչ տեսության հետ է, արդեն կարելի է փորձել ինչ-որ բան գրել։ Ցուցասարքի հետ աշխատելը հեշտացնելու համար ես փոքրիկ գրադարան եմ պատրաստել, հիմա տեսնենք, թե ինչպես կարելի է այն օգտագործել։ Նախ, ներբեռնեք

Մենք մեր տրամադրության տակ ենք ստանում 2 ֆայլ՝ MT_WH1602.c և MT_WH1602.h: Մենք պոկում ենք երկրորդը, այստեղ մենք պետք է ընտրենք կապում և օգտագործված կարգավորիչը:

Ի դեպ, իմ էկրանը միացված է այսպես.

RS-PC2
R/W – PB10
E – PB14
DB7–PD2
DB6–PC12
DB5–PA8
DB4–PA10
DB3–PA15
DB2–PD11
DB1–PA3
DB0–PA5

Բացեք MT_WH1602.h ֆայլը.

#define PLATFORM (STM32F10x)

Հաջորդը, ընտրեք միկրոկառավարիչի կապում, որոնց միացված է էկրանը: Պարզապես նախ եկեք սահմանենք, թե որ նավահանգիստներն ենք մենք օգտագործում: Երբ միանում եմ, օգտագործում եմ GPIOA, GPIOB, GPIOC և GPIOD, գրում ենք.

Նմանապես այլ միկրոկոնտրոլերի ոտքերի համար:

Ավարտեցինք կարգավորումը, շարունակենք) Հոդվածի սկզբում տրված հրամանները կանչելու համար MT_WH1602.c ֆայլը պարունակում է հետևյալ գործառույթները (դրանք անվանվել են հրամանների անուններով, այնպես որ, կարծում եմ, ամեն ինչ պարզ է) :

void MT_WH1602_ClearDisplay(void); void MT_WH1602_ReturnHome(void) ; void MT_WH1602_EntryModeSet (bool ID հասցե, bool shift) ; void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; void MT_WH1602_CursorOrDisplayShift (bool SCbit, bool RLbit); void MT_WH1602_FunctionSet (bool DLbit, bool Nbit, bool Fbit); void MT_WH1602_SetCGRAMaddress (uint8_t հասցե) ; void MT_WH1602_SetDDRAMaddress (uint8_t հասցե) ; bool MT_WH1602_ReadBusy(void); void MT_WH1602_WriteData(uint8_t տվյալներ) ;

Որոշ հրամանների համար մենք պետք է պարամետրեր փոխանցենք ֆունկցիային, օրինակ.

void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ;

Եկեք նայենք հրամանի աղյուսակին.

Մենք տեսնում ենք, որ Display ON/OFF հրամանը ոչ միայն միացնում/անջատում է էկրանը, այլև ակտիվացնում/անջատում է կուրսորը և թարթող կուրսորը: Տվյալների թերթիկում այս հրամանի բիթերը նշանակված են որպես D, C և B, և մենք դրանք փոխանցում ենք ֆունկցիային որպես պարամետրեր: Եթե ​​մեզ անհրաժեշտ է միացնել էկրանը և կուրսորը, բայց անջատել կուրսորի թարթումը, մենք կանչում ենք հրամանը հետևյալ կերպ.

MT_WH1602_DisplayOnOff(1, 1, 0);

Ընդհանրապես ամեն ինչ պարզ է 😉

Մի խոսքով, մենք ստեղծում ենք նոր նախագիծ, ավելացնում ենք գրադարան WH1602 էկրանի հետ աշխատելու համար, ստեղծում ենք դատարկ .c ֆայլ և սկսում ենք այն լրացնել կոդով.

// Ներառեք գրադարանի ֆայլը#include «MT_WH1602.h» /*******************************************************************/ int main (անվավեր) ( // Կանչեք սկզբնավորման գործառույթը, մենք չենք կարող առանց դրա =)() ; // Այժմ մենք պետք է կատարենք ցուցադրման սկզբնական կոնֆիգուրացիան // Փաստաթղթերը և ինտերնետը խորհուրդ են տալիս դա անել;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay (1000); MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay (1000); MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay (1000); MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay (1000); MT_WH1602_DisplayOnOff (1, 0, 0); MT_WH1602_Delay (1000); MT_WH1602_ClearDisplay(); MT_WH1602_Delay (2000); // Օրինակ, ես վերցրեցի առաջին ուշացման արժեքները, որոնք մտքովս անցան) // Ընդհանուր առմամբ, դուք պետք է ստուգեք ցուցադրման զբաղված դրոշը // Հիմա եկեք ցուցադրենք ինչ-որ բան, օրինակ մեր կայքի անունը MT_WH1602_WriteData (0x6D); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x69); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x63); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x72); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x6F); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x74); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x65); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x63); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x68); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x6E); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x69); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x63); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x73); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x2E); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x72); MT_WH1602_Delay (100); MT_WH1602_WriteData (0x75); MT_WH1602_Delay (100); մինչդեռ (1) (__NOP() ;)) /*******************************************************************/

Ավարտված է, եկեք ստուգենք)


Ինչպես տեսնում եք, ամեն ինչ ճիշտ է աշխատում)

Ի դեպ, ինչ-որ կերպ աչքիս ընկավ այն հարցը, թե ինչ գրել ցուցասարքի վրա, որպեսզի ցուցադրեմ այս կամ այն ​​կերպարը։ Ահա տվյալների թերթիկի ափսեը.

Այսպիսով, որոշելու համար, թե ինչ արժեք պետք է գրել ցուցադրման հիշողության մեջ, դուք պետք է վերցնեք վերևում գրված և այս աղյուսակում թողած թվերը որոշակի նշանի համար: Օրինակ՝ «A» նշանը։ Տեսնենք՝ այս նշանը համապատասխանում է 0100 (0x4) սյունակին և 0001 տողին (0x1): Պարզվում է, որ «A» նշանը ցուցադրելու համար էկրանին պետք է գրել 0x41 արժեքը:

Ահա և վերջ =) Մենք կարգավորել ենք WH1602 էկրանի միացումը և աշխատանքը, այնպես որ շուտով կտեսնվենք:

P.S. Գրադարանի հետ աշխատելիս ես չեմ փորձարկել զբաղված դրոշը կարդալու գործառույթը, այնպես որ, եթե հանկարծ ինչ-որ բան այնպես չաշխատի, ինչպես պետք է, գրեք, մենք դա կպարզենք)

• FC-113 մոդուլը հիմնված է PCF8574T չիպի վրա, որը 8-բիթանոց հերթափոխային ռեգիստր է՝ մուտքային-ելքային «ընդլայնող» 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 ()	միացնել autoscroll;
noAutoscroll()	անջատել autoscroll-ը;
ձախից աջ ()	սահմանում է տեքստի ուղղությունը ձախից աջ;
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 "); } void loop() (// թարթում է վերջին նիշը lcd.setCursor(13, 1); // կուրսորը տեղափոխել տող 2, նիշ 1 lcd.print("\t"); ուշացում (500); lcd.setCursor (13, 1); // կուրսորը տեղափոխել տող 2, նիշ 1 lcd.print(" "); ուշացում (500); }

Ի դեպ, հրամանով գրված նիշերը lcd.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 ավտոբուս

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

Լատինական «A», «B» և «C» նիշերի թողարկման ժամանակացույցը LCD էկրանին 1602

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

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

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