LSD ეკრანის კავშირი. Სავარჯიშო კურსი

ყოველი რადიომოყვარული, გარკვეული რაოდენობის მარტივი ხელნაკეთი პროექტების შემდეგ, მიზანს უახლოვდება სენსორებისა და ღილაკების გამოყენებით რაიმე გრანდიოზული ააშენოს. ყოველივე ამის შემდეგ, ბევრად უფრო საინტერესოა მონაცემების ჩვენება ეკრანზე, ვიდრე პორტის მონიტორზე. მაგრამ შემდეგ ჩნდება კითხვა: რომელი ჩვენება აირჩიოს? და საერთოდ, როგორ დავაკავშიროთ, რა არის საჭირო დასაკავშირებლად? ამ კითხვებზე პასუხები განხილული იქნება ამ სტატიაში.

LCD 1602

ჩვენების მრავალ ვარიანტს შორის, მინდა კონკრეტულად აღვნიშნო LCD1602 დისპლეი, რომელიც დაფუძნებულია HD4478 კონტროლერზე. ეს ჩვენება ხელმისაწვდომია ორ ფერში: თეთრი ასოები ლურჯ ფონზე, შავი ასოები ყვითელ ფონზე. LCD 1602-ის Arduino-სთან დაკავშირება ასევე არ გამოიწვევს რაიმე პრობლემას, რადგან არის ჩაშენებული ბიბლიოთეკა და არ არის საჭირო რაიმე დამატებითი ჩამოტვირთვა. დისპლეები განსხვავდება არა მხოლოდ ფასით, არამედ ზომითაც. ხშირად, რადიომოყვარულები იყენებენ 16 x 2, ანუ 16 სიმბოლოს 2 ხაზს. მაგრამ ასევე არის 20 x 4, სადაც არის 20 სიმბოლოს 4 ხაზი. ზომები და ფერი არანაირ როლს არ თამაშობს LCD 1602 დისპლეის Arduno-სთან დაკავშირებაში; ისინი დაკავშირებულია იმავე გზით. ხედვის კუთხე 35 გრადუსია, ეკრანის რეაგირების დრო 250 ms. მას შეუძლია იმუშაოს ტემპერატურაზე -20-დან 70 გრადუს ცელსიუსამდე. ექსპლუატაციის დროს ის იყენებს 4 mA-ს ეკრანისთვის და 120 mA-ს განათებისთვის.

სად გამოიყენება?

ეს ჩვენება პოპულარულია არა მხოლოდ რადიომოყვარულებში, არამედ დიდ მწარმოებლებს შორის. მაგალითად, პრინტერები და ყავის აპარატები ასევე იყენებენ LCD1602. ეს გამოწვეულია მისი დაბალი ფასით, ჩინურ საიტებზე ეს ჩვენება 200-300 რუბლს შეადგენს. ღირს იქ ყიდვა, რადგან ჩვენს მაღაზიებში ამ ჩვენების მარკირება ძალიან მაღალია.

არდუინოსთან დაკავშირება

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); // დააყენეთ კურსორი სტრიქონის 2 დასაწყისში lcd.print("საიტი") ; // ტექსტის გამოტანა ) void loop ()( )

რას აკეთებს კოდი? პირველი ნაბიჯი არის ბიბლიოთეკის დაკავშირება ეკრანთან მუშაობისთვის. როგორც ზემოთ აღინიშნა, ეს ბიბლიოთეკა უკვე შედის Arduino IDE-ში და არ საჭიროებს დამატებით ჩამოტვირთვას და ინსტალაციას. შემდეგი, განისაზღვრება კონტაქტები, რომლებიც დაკავშირებულია ქინძისთავებთან: RS, E, DB4, DB5, DB6, DB7, შესაბამისად. შემდეგ დაყენებულია ეკრანის ზომა. ვინაიდან ჩვენ ვმუშაობთ ვერსიაზე 16 სიმბოლოთი და 2 ხაზით, ვწერთ შემდეგ მნიშვნელობებს. ჩვენ ვათავსებთ კურსორს პირველი ხაზის დასაწყისში და ვაჩვენებთ ჩვენს პირველ ტექსტს Hello World. შემდეგი, მოათავსეთ კურსორი მეორე ხაზზე და აჩვენეთ საიტის სახელი. Სულ ეს არის! გათვალისწინებული იყო LCD 1602-ის Arduino Uno-სთან დაკავშირება.

რა არის I2C და რატომ არის საჭირო?

როგორც ზემოთ აღინიშნა, ეკრანის დაკავშირება ბევრ კონტაქტს იკავებს. მაგალითად, რამდენიმე სენსორთან და LCD ეკრანთან მუშაობისას, 1602 ქინძისთავი შეიძლება უბრალოდ არ იყოს საკმარისი. ხშირად, რადიომოყვარულები იყენებენ Uno ან Nano ვერსიებს, რომლებსაც ბევრი კონტაქტი არ აქვთ. შემდეგ ხალხი გამოვიდა სპეციალური ფარებით. მაგალითად, I2C. ის საშუალებას გაძლევთ დააკავშიროთ ეკრანი მხოლოდ 4 პინით. ეს ორჯერ მეტია. I2C მოდული იყიდება როგორც ცალ-ცალკე, სადაც თქვენ თვითონ უნდა შეადუღოთ, ასევე უკვე დამაგრებულია LCD 1602 ეკრანზე.

კავშირი I2C მოდულის გამოყენებით

LCD 1602 Arduino Nano-სთან I2C-ით დაკავშირება მცირე ადგილს იკავებს, მხოლოდ 4 პინი: დამიწება, დენი და 2 მონაცემთა გამომავალი. ჩვენ ვაკავშირებთ სიმძლავრეს და დამიწებას Arduino-ზე, შესაბამისად, 5V-ს და GND-ს. ჩვენ ვუკავშირდებით დარჩენილ ორ კონტაქტს: SCL და SDA ნებისმიერ ანალოგურ პინებს. ფოტოში შეგიძლიათ იხილოთ LCD 1602-ის არდუინოსთან I2C მოდულით დაკავშირების მაგალითი:

პროგრამის კოდი

თუ მოდულის გარეშე დისპლეით მუშაობისთვის საჭირო იყო მხოლოდ ერთი ბიბლიოთეკის გამოყენება, მაშინ მოდულთან მუშაობისთვის საჭიროა ორი ბიბლიოთეკა. ერთი მათგანი უკვე შედის Arduino IDE - Wire-ში. სხვა ბიბლიოთეკა, LiquidCrystal I2C, ცალკე უნდა იყოს გადმოწერილი და დაინსტალირებული. Arduino-ში ბიბლიოთეკის დასაყენებლად, გადმოწერილი არქივის შიგთავსი უნდა ჩაიტვირთოს root ბიბლიოთეკების საქაღალდეში. პროგრამის კოდის მაგალითი 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	1	0
0	0	0	1
1	1	0	1
0	0	0	1
1	1	0	1
0	0	0	1
0	0	1	0
0	0	0	0

თუ 0 - იქ არაფერია, თუ 1 - ეს არის მოხატული ადგილი. ზემოთ მოცემულ მაგალითში შეგიძლიათ იხილოთ "ღიმილიანი ღიმილის" სიმბოლოს შექმნა. არდუინოში მაგალითის პროგრამის გამოყენება ასე გამოიყურება:

#შეიცავს #შეიცავს // დაამატეთ საჭირო ბიბლიოთეკა // ღიმილის სიმბოლოს ბიტი ნიღაბი ბაიტი smile = ( 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, smile); // შექმენით სიმბოლოს ნომერი 1 lcd.setCursor(0, 0); // დააყენეთ კურსორი 1 სტრიქონის დასაწყისში lcd.print("\1"); // აჩვენეთ ღიმილიანი სახე (სიმბოლო ნომერი 1) - "\1" ) void loop ())()

როგორც ხედავთ, ბიტმასკი შეიქმნა ისევე, როგორც ცხრილი. შექმნის შემდეგ, ის შეიძლება გამოჩნდეს ცვლადის სახით ეკრანზე. გახსოვდეთ, რომ მეხსიერებაში შეგიძლიათ შეინახოთ მხოლოდ 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) - ჩართვა (სტრობი დაცემაზე)
7-10 (DB0-DB3) - 8-ბიტიანი ინტერფეისის დაბალი რიგის ბიტები
11-14 (DB4-DB7) - ინტერფეისის მაღალი რიგის ბიტები
15 (A) - ანოდური (+) განათების კვების წყარო
16 (K) - კათოდური (-) განათების კვების წყარო

თვითშემოწმების რეჟიმი:

სანამ ცდილობთ ინფორმაციის დაკავშირებას და ჩვენებას, კარგი იქნებოდა გაარკვიოთ მუშაობს თუ არა ეკრანი. ამისათვის თქვენ უნდა გამოიყენოთ ძაბვა თავად კონტროლერზე ( VSS და VDD), ჩართეთ უკანა განათება ( ა და კ), ასევე დაარეგულირეთ კონტრასტი.

კონტრასტის დასარეგულირებლად გამოიყენეთ 10 kOhm პოტენციომეტრი. არ აქვს მნიშვნელობა როგორი ფორმა იქნება. +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 MHz-ს. პირადად მე არ მიცდია. მე მაქვს ყველაფერი აწყობილი გამართვის დაფაზე, რომელიც იკვებება 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 ms. არქივს ვამატებ შედგენილ პროექტთან ერთად. სიხშირე 8 MHz.

მაგრამ როგორც უკვე დავწერე დასაწყისში, ბიბლიოთეკაში სხვა სიმბოლოებიც არის. მართალია, არ არის ასოები, მხოლოდ რიცხვები. ახლა ცოტა გავართულოთ დავალება. დაე, წარწერა არ იყოს ინერტული, მაგრამ შეიცვალოს. ვთქვათ, ითვლის 0-დან 9-მდე 1 წამის ინტერვალით. როდესაც ის 9-ს მიაღწევს, ის გადაიტვირთება ნულამდე და დაიწყება თავიდან. ავიღოთ დიდი რიცხვები 24*32. აბა, დავიწყოთ. თქვენ შეგიძლიათ აიღოთ წინა პროექტი და წაშალოთ სამი "print_string" ხაზი. ბიბლიოთეკების დამატებისთანავე გამოვაცხადოთ გარკვეული გლობალური ცვლადი. მ.

char m = 0;

თქვენ უბრალოდ შეგიძლიათ დაწეროთ:

ამ შემთხვევაში, მას ავტომატურად მიენიჭება მნიშვნელობა 0. მთავარ ციკლში ჩვენ ვწერთ ამას:

char_24_32(მ,35,2); //სიმბოლო გამომავალი ფუნქცია 24*32
დაგვიანებით_ms(1000); // დაელოდეთ 1 წამს
m++; // დაამატეთ 1 ცვლადს m
if(m>9)m=0; // მდგომარეობა. თუ ცვლადი m მეტია 9-ზე, მაშინ m უდრის 0-ს.

გადავიღე პროგრამის მუშაობის მოკლე ვიდეო

შევეცდები გითხრათ, როგორ დავხატოთ სურათები და გამოვაჩინოთ ისინი ჩვენების ეკრანზე. როგორ შევქმნათ მასივები და ფუნქციები, რომ გამოვიტანოთ ისინი და როგორ უნდა გადააკეთოთ სურათი. ბიბლიოთეკები ნასესხები იყო საიტიდან cxem.net. მომზადებული მასალა ბუზერი.

იმსჯელეთ სტატია, რომელიც აკავშირებს ეკრანს მიკროკონტროლერთან

რა არის დიდი რაოდენობით ელექტრონული მოწყობილობების განუყოფელი ნაწილი? რა თქმა უნდა, მითითების საშუალებები და მონაცემთა გრაფიკული გამომუშავება. მომხმარებლისთვის ყოველთვის უფრო მოსახერხებელი და სასიამოვნოა, როდესაც "ჭკვიანი ყუთის" შედეგი ვიზუალურად ჩანს. აქედან გამომდინარე, დღეს ჩვენ დავაკავშირებთ ეკრანს STM32- ს ტექსტისა და ციფრების სანახავად. ჩვენი ექსპერიმენტების გმირი უინსტარისგან საკმაოდ პოპულარული ჩვენება იქნება. სხვათა შორის, მნიშვნელოვანი განმარტება გამოჩნდა კომენტარებში, რომ მეთოდოლოგია ძირითადად იგივეა ყველა ჩვენებისთვის HD44780.მადლობა JekaKey-ს მნიშვნელოვანი დანამატისთვის)

პირველი, ეკრანი უნდა იყოს დაკავშირებული კონტროლერთან. ჩამოტვირთეთ მონაცემთა ცხრილი და მოძებნეთ WH1602 pinout. ნახე აქ:

Როგორც იცით, WH1602 ჩვენებააქვს 16 პინი. თითოეულს ცალ-ცალკე შევხედოთ...

ქინძისთავები Vss, Vdd და K უნდა იყოს დაკავშირებული მიწასთან და ელექტროენერგიასთან, ანუ ზუსტად ისე, როგორც ცხრილშია მითითებული, არ არის სიურპრიზები და განსახილველიც კი არაფერია)

ქინძისთავი ნომერი 3 გამოიყენება კონტრასტის დასარეგულირებლად - თუ იქ +5V-ს მივაყენებთ, აბსოლუტურად ვერაფერს დავინახავთ, ხოლო თუ ქინძისთავს მიწასთან მოკლედ შევაერთებთ, აღფრთოვანებული ვიქნებით შავი კვადრატის ორი რიგით 😉 ბუნებრივია, ეს არ გვიწყობს. , ასე რომ, ჩვენ უნდა დავკიდოთ პოტენომეტრი (რეზისტორი) იქ ცვლადი წინააღმდეგობის გაწევით) კონტრასტის შესწორების მიზნით. პერსონაჟების საუკეთესო ხილვადობას მოცემულია ძაბვა 0.5-0.7 V ამ ეკრანზე.

RS პინი უკვე არის პინი, რომელსაც ჩვენ თვითონ გავაკონტროლებთ მიკროკონტროლერის გამოყენებით. დაბალი ძაბვის დონე (0) ამ პინზე ნიშნავს, რომ ახლა მოჰყვება ბრძანება, მაღალი დონე (1) ნიშნავს, რომ ახლა იქნება მონაცემები, რომლებიც უნდა ჩაიწეროს ეკრანის მეხსიერებაში.

Pin R/W - აქ გასაგებია, ან ჩვენ ვკითხულობთ მონაცემებს (მაგალითად, ჩვენ ვაჩვენებთ დაკავებულ დროშას), ამ შემთხვევაში ამ პინზე არის 1, ან ჩვენ ვწერთ ბრძანებას/მონაცემებს ეკრანზე, შემდეგ გვაქვს 0.

DB7 – DB0 – მონაცემთა ავტობუსი და ამით ყველაფერი ნათქვამია)

Pin E არის ეგრეთ წოდებული Enable სიგნალი. ეს არის ის, რისთვისაც ის საჭიროა. ეკრანთან მუშაობისთვის - მონაცემების ჩაწერა ან ბრძანების გაცემა - ამ პინზე დადებითი პულსი უნდა გამოვუშვათ. ანუ, პროცედურა ასე გამოიყურება:

ქინძისთავები RS, R/W, DB7 - DB0 - ჩვენი ბრძანების შესაბამისი საჭირო სიგნალები.
ჩვენ ვაწვდით ერთს პინზე E.
ჟდემები (მონაცემთა ფურცლის მიხედვით - მინიმუმ 150 ნს)
ჩვენ ვიყენებთ დაბალ დონეს (0) PIN 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 mt_wh1602_returnhome (ბათილად); 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 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(void) ( // გამოიძახეთ ინიციალიზაციის ფუნქცია, ამის გარეშე არ შეგვიძლია =)() ; // ახლა ჩვენ უნდა გავაკეთოთ საწყისი ჩვენების კონფიგურაცია // დოკუმენტაცია და ინტერნეტი გირჩევთ ამის გაკეთებას ;) 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" დაყენებულ ჯემპერს. ნაგულისხმევად, სამივე ჯემპერი ღიაა და მოწყობილობის მისამართი 0x27.

2 LCD დისპლეის დაკავშირების დიაგრამა Arduino-სთან I2C პროტოკოლის საშუალებით

მოდული უკავშირდება Arduino-ს სტანდარტული გზით I2C ავტობუსისთვის: მოდულის SDA პინი უკავშირდება ანალოგურ პორტს A4, SCL პინი უკავშირდება Arduino-ს ანალოგურ პორტს A5. მოდული იკვებება +5 ვ-ით Arduino-დან. თავად მოდული დაკავშირებულია 1…16 ქინძისთავებით LCD დისპლეის შესაბამის 1…16 ქინძისთავებთან.

3 ბიბლიოთეკა სამუშაოდ I2C პროტოკოლის საშუალებით

ახლა ჩვენ გვჭირდება ბიბლიოთეკა LCD-თან მუშაობისთვის I2C ინტერფეისის საშუალებით. თქვენ შეგიძლიათ გამოიყენოთ, მაგალითად, ეს (ბმული "ჩამოტვირთეთ ნიმუშის კოდი და ბიბლიოთეკა").

გადმოწერილი არქივი LiquidCrystal_I2Cv1-1.rarგახსენით საქაღალდეში \ბიბლიოთეკები\, რომელიც მდებარეობს Arduino IDE დირექტორიაში.

ბიბლიოთეკა მხარს უჭერს სტანდარტული ფუნქციების კომპლექტს LCD ეკრანებისთვის:

ფუნქცია	მიზანი
თხევადი კრისტალი ()	ქმნის LiquidCrystal ტიპის ცვლადს და იღებს დისპლეის კავშირის პარამეტრებს (პინის ნომრებს);
დაწყება ()	LCD დისპლეის ინიციალიზაცია, პარამეტრების დაყენება (ხაზების და სიმბოლოების რაოდენობა);
ნათელი ()	ეკრანის გასუფთავება და კურსორის დაბრუნება საწყის პოზიციაზე;
სახლი ()	დააბრუნეთ კურსორი საწყის პოზიციაზე;
setCursor()	კურსორის დაყენება მოცემულ პოზიციაზე;
დაწერე ()	აჩვენებს სიმბოლოს LCD ეკრანზე;
ბეჭდვა ()	აჩვენებს ტექსტს LCD ეკრანზე;
კურსორი ()	აჩვენებს კურსორს, ე.ი. შემდეგი სიმბოლოს ადგილის ქვეშ ხაზგასმა;
noCursor()	მალავს კურსორს;
თვალის დახამხამება()	კურსორის მოციმციმე;
noBlink ()	ციმციმის გაუქმება;
არაჩვენება ()	ეკრანის გამორთვა ყველა ნაჩვენები ინფორმაციის შენახვისას;
ჩვენება ()	ეკრანის ჩართვა ყველა ნაჩვენები ინფორმაციის შენახვისას;
scrollDisplayLeft()	გადაახვიეთ ეკრანის შიგთავსი 1 პოზიციაზე მარცხნივ;
scrollDisplayRight()	გადაახვიეთ ეკრანის შიგთავსი 1 პოზიციაზე მარჯვნივ;
autoscroll()	ჩართეთ ავტომატური გადახვევა;
noAutoscroll()	ავტომატური გადახვევის გამორთვა;
მარცხნიდან მარჯვნივ()	ადგენს ტექსტის მიმართულებას მარცხნიდან მარჯვნივ;
rightToLeft ()	ტექსტის მიმართულება მარჯვნიდან მარცხნივ;
createChar()	ქმნის ჩვეულებრივ პერსონაჟს LCD ეკრანისთვის.

4 ესკიზი ტექსტის გამოსატანად LCD ეკრანზე i2c ავტობუსის საშუალებით

მოდით გავხსნათ ნიმუში: ფაილის ნიმუშები LiquidCrystal_I2C CustomCharsდა ჩვენ ამას ცოტათი ვამუშავებთ. ჩვენ გამოვაჩენთ შეტყობინებას, რომლის ბოლოს მოციმციმე სიმბოლო იქნება. კოდის კომენტარები კომენტარს აკეთებს ესკიზის ყველა ნიუანსზე.

#შეიცავს // ჩართეთ მავთულის ბიბლიოთეკა #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();, რჩება ეკრანის მეხსიერებაში დენის გამორთვის შემდეგაც, რადგან დაწერილია ROM 1602-ის საჩვენებლად.

5 შექმენით თქვენი საკუთარი სიმბოლოები LCD ეკრანისთვის

მოდით უფრო დეტალურად განვიხილოთ LCD ეკრანებისთვის საკუთარი სიმბოლოების შექმნის საკითხი. ეკრანზე თითოეული სიმბოლო შედგება 35 წერტილისგან: 5 სიგანე და 7 მაღალი (+1 სარეზერვო ხაზი ხაზგასმისთვის). ზემოთ მოყვანილი ესკიზის მე-6 სტრიქონში ჩვენ განვსაზღვრავთ 7 რიცხვის მასივს: (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). გადაიყვანეთ თექვსმეტობითი რიცხვები ორობითად: {00000, 01010, 11111, 11111, 01110, 00100, 00000} . ეს რიცხვები სხვა არაფერია, თუ არა ბიტი ნიღბები სიმბოლოს 7 სტრიქონიდან თითოეულისთვის, სადაც "0" აღნიშნავს ნათელ წერტილს და "1" ბნელ წერტილს. მაგალითად, ბიტმასკის სახით მითითებული გულის სიმბოლო გამოჩნდება ეკრანზე, როგორც ნაჩვენებია სურათზე.

6 LCD ეკრანის კონტროლი I2C ავტობუსით

მოდით ავტვირთოთ ესკიზი Arduino-ზე. ეკრანზე გამოჩნდება წარწერა, რომელიც ჩვენ დავასახელეთ მოციმციმე კურსორით.

7 რა არის უკან I2C ავტობუსი

როგორც პრემია, მოდით განვიხილოთ ლათინური სიმბოლოების "A", "B" და "C" ნაჩვენები დროული დიაგრამა LCD ეკრანზე. ეს სიმბოლოები ინახება დისპლეის ROM- ში და ეკრანზე ნაჩვენებია მხოლოდ მათი მისამართების ეკრანზე გადასვლის გზით. დიაგრამა აღებულია ეკრანის RS, RW, E, D4, D5, D6 და D7 ქინძისთავებიდან, ე.ი. უკვე FC-113 "I2C პარალელური ავტობუსის" გადამყვანი. შეგვიძლია ვთქვათ, რომ ჩვენ ოდნავ ღრმად ვყვირით აპარატურაში.

LCD ეკრანზე ლათინური სიმბოლოების "A", "B" და "C" გამოშვების დროული დიაგრამა 1602

დიაგრამა გვიჩვენებს, რომ სიმბოლოები, რომლებიც ეკრანზეა ROM (იხ. მონაცემთა ცხრილის გვ. 11, ქვემოთ მოცემულია ბმული), გადადის ორ ნიბლში, რომელთაგან პირველი განსაზღვრავს ცხრილის სვეტის ნომერს, ხოლო მეორე - რიგის ნომერი. ამ შემთხვევაში, მონაცემები "შეფუთულია" ხაზის სიგნალის პირას ე(ჩართვა) და ხაზი რ.ს.(რეგისტრაცია აირჩიეთ) არის ლოგიკურ ერთ მდგომარეობაში, რაც ნიშნავს მონაცემთა გადაცემას. RS ხაზის დაბალი მდგომარეობა ნიშნავს ინსტრუქციების გაგზავნას, რასაც ვხედავთ თითოეული სიმბოლოს გადაცემამდე. ამ შემთხვევაში გადადის LCD დისპლეის პოზიციაზე (0, 0) დაბრუნების ინსტრუქციის კოდი, რომლის გარკვევაც შესაძლებელია დისპლეის ტექნიკური აღწერილობის შესწავლით.

და კიდევ ერთი მაგალითი. ეს დროის დიაგრამა აჩვენებს გულის სიმბოლოს გამომავალს LCD ეკრანზე.

ისევ პირველი ორი იმპულსი ჩართვაშეასრულოს ინსტრუქციები მთავარი ()(0000 0010 2) - დააბრუნეთ ვაგონი პოზიციაზე (0; 0), ხოლო მეორე ორი - გამომავალი LCD ეკრანზე, რომელიც ინახება მეხსიერების უჯრედში 3 10 (0000 0011 2) სიმბოლო „გული“ (ინსტრუქცია lcd.createChar(3, გული);ესკიზი).