i2c კავშირი. LCD ეკრანის LCM1602 I2C-თან დაკავშირება Arduino-სთან

  • FC-113 მოდული დაფუძნებულია PCF8574T ჩიპზე, რომელიც არის 8-ბიტიანი ცვლის რეგისტრი - I/O ექსპანდერი I2C სერიული ავტობუსისთვის. ფიგურაში, მიკროსქემა დანიშნულია DD1.
  • R1 - ტრიმერი LCD დისპლეის კონტრასტის დასარეგულირებლად.
  • Jumper J1 გამოიყენება ეკრანის განათების ჩასართავად.
  • ქინძისთავები 1…16 გამოიყენება მოდულის დასაკავშირებლად LCD ეკრანის ქინძისთავებთან.
  • მოწყობილობის I2C მისამართის შესაცვლელად საჭიროა საკონტაქტო ბალიშები A1 ... A3. შესაბამისი ჯემპერის შედუღებით შეგიძლიათ შეცვალოთ მოწყობილობის მისამართი. ცხრილი აჩვენებს მისამართებსა და ჯუმპერებს შორის შესაბამისობას: "0" შეესაბამება ღია წრეს, "1" - დამონტაჟებულია ჯუმპერი. ნაგულისხმევად, სამივე ჯემპერი ღიაა და მოწყობილობის მისამართი 0x27.

2 არდუინოს LCD დისპლეის გაყვანილობის დიაგრამა 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და ცოტა შევცვალოთ. ვაჩვენოთ შეტყობინება, რომლის ბოლოს მოციმციმე სიმბოლო იქნება. ესკიზის ყველა ნიუანსი კომენტირებულია კოდის კომენტარებში.

#შეიცავს // მოიცავს 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 პარალელური ავტობუსის" შემდეგ. შეიძლება ითქვას, რომ „რკინაში“ ცოტა „ღრმად“ ჩავდივართ.


ლათინური სიმბოლოების "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, გული);ესკიზი).

ალბათ ერთ-ერთი ყველაზე პოპულარული ეკრანი ბაზარზე. აგებულია პოპულარულ HD44780U კონტროლერზე. მოდელის სახელიდან გამომდინარეობს, რომ ეკრანი შედგება 16 სიმბოლოსგან შემდგარი ორი ხაზისგან. ამ კონკრეტულ მოდელში რუსული ენის მხარდაჭერა არ არის.

sh2s მონაცემთა ავტობუსი საშუალებას გაძლევთ დააკავშიროთ 127-მდე მოწყობილობა ორი მავთულის საშუალებით და ამავე დროს. ეს I2C დანერგილია PCF8574T ჩიპზე.

გაყვანილობის დიაგრამა:

ცისფერი რამ - ცვლადი წინააღმდეგობა, საშუალებას გაძლევთ დაარეგულიროთ ეკრანის კონტრასტი.

მარცხნივ ჯუმპერი პასუხისმგებელია ეკრანის განათებაზე.

4 პინიანი ბლოკი დაკავშირებულია არდუინოსთან ასე:

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"); ) void loop () ( )

LCD I2C მოდული საშუალებას გაძლევთ დააკავშიროთ სიმბოლოების ჩვენება Arduino დაფას მხოლოდ ორი სიგნალის მავთულით.

გამოყენებული კომპონენტები (შეიძინეთ ჩინეთიდან):

. საკონტროლო დაფა

. დამაკავშირებელი სადენები

ძირითადი ტექნიკური მახასიათებლები:

ეკრანი: სიმბოლო 16x02 ან 20x04
. განათება: ლურჯი თეთრი სიმბოლოებით
. კონტრასტი: რეგულირდება პოტენციომეტრით
. მიწოდების ძაბვა: 5V
. ინტერფეისი: I2C
. I2C მისამართი: 0x27
. ზომები: 82 მმ x 35 მმ x 18 მმ

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

მოდული აღჭურვილია ოთხპინიანი 2.54მმ კონექტორით

SCL: სერიული საათის ხაზი (სერიული საათი)

SDA: სერიული მონაცემთა ხაზი (სერიული მონაცემები)

VCC: "+" სიმძლავრე

GND: "-" ძალა

სხვადასხვა კონტროლერზე დაფუძნებული I2C ინტერფეისისთვის პასუხისმგებელი ქინძისთავები Arduino დაფებზე განსხვავებულია

ამ მოდულთან მუშაობისთვის, თქვენ უნდა დააინსტალიროთ LiquidCrystal_I2C1602V1 ბიბლიოთეკა

ჩამოტვირთეთ, ამოალაგეთ და ჩააგდეთ ბიბლიოთეკების საქაღალდეში Arduino საქაღალდეში. თუ ბიბლიოთეკის დამატების დროს Arduino IDE ღია იყო, გადატვირთეთ გარემო.

მოდით პირდაპირ ესკიზზე გადავიდეთ. ამ მაგალითში ჩვენ გამოვაჩენთ სტანდარტს "გამარჯობა, სამყარო!" და ჩვენი საზოგადოების მისამართით.

კოდის მაგალითი:

#შეიცავს #შეიცავს LiquidCrystal_I2C LCD (0x27,16,2); /* დააყენეთ ეკრანის მისამართი და ზომა. LCD I2C მოდულის გამოყენებისას 20x04 დისპლეით, კოდში არაფერი უნდა შეიცვალოს, თქვენ უბრალოდ უნდა დააყენოთ სწორი განზომილება */ბათილად აწყობა() (lcd.init(); // LCD-ის ინიციალიზაცია LCD.backlight(); // ჩართეთ უკანა განათება // კურსორი არის პირველი ხაზის დასაწყისში 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_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-ის მაღაზიიდან სხვა მოწყობილობა, რომ შევისწავლო და გამოვიყენო ის სასარგებლო მოწყობილობებში. აღმოჩნდა, რომ ეს მოწყობილობა გამკაცრდა LCD დისპლეის გასაკონტროლებლად HD44780 კონტროლერის კონტროლის ქვეშ, 4 ბიტიან რეჟიმში. ამ მიზნით დაფაზე დამონტაჟებულია მიკროსქემა, რომელიც წარმოადგენს I2C ავტობუსის გადამყვანს პარალელურ 8-ბიტიან პორტში.

დაფა ისეა გაყოფილი, რომ მისი დაუყოვნებლივ გადაკვეთა შესაძლებელია LCD დისპლეით. შეყვანა იკვებება და I2C ხაზები. დაფას დაუყოვნებლივ აქვს ასაწევი რეზისტორები SCL და SDA ხაზებზე, პოტენციომეტრი კონტრასტის დასარეგულირებლად და თავად დისპლეის გასაძლიერებლად.

მარცხნივ ჯუმპერი რთავს/გამორთავს უკანა განათებას. შემდეგ, ტესტერით შეიარაღებული, შეადგინეს შემდეგი ფირფიტა. მოდულის შესწავლის შემდეგ აღმოჩნდა, რომ P3აკონტროლებს უკანა განათებას. თუ ჯუმპერი დაყენებულია, მაშინ 1 ჩართავს უკანა განათებას და 0 გამორთავს მას. როდესაც ჯუმპერი ამოღებულია, უკანა განათება ყოველთვის გამორთულია. გარდა ამისა, გადაწყდა 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); _ დაგვიანებით_ჩვენ(40); com (0x30); // 4-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(40); // ბრძანების შესრულების დაყოვნება com (0x30); // 4-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(40); // ბრძანების შესრულების დაყოვნება com (0x20); // 4-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(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 data) ( BYTE data_h = ((data & 0xF0) + 0x09); BYTE data_l = ((data // Pass high 4 bit 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!" ); while (1) ( ) )ზუსტად ის, რაც აქ ხდება. პირველ რიგში, ჩვენ ვაერთიანებთ ბიბლიოთეკებს I2C-სთვის და PCF8574-ისთვის. I2C-ზე უკვე დავწერე, ამიტომ ჯვარს აღარ გავაკრავ, მაგრამ PCF8574.h-ში გეტყვით რა. ბიბლიოთეკა მოიცავს მხოლოდ სამ ფუნქციას.
BYTE pcf8574_test(BYTE დამატება) (BYTE შეკითხვა = ACK; დამატება &= 0xFE; i2c_start(); ask = i2c_send_byte(add); i2c_stop(); დაბრუნება თხოვნა; )პირველი ფუნქცია დაიწერა იმის შესამოწმებლად, არის თუ არა მოწყობილობა ავტობუსში. პრინციპში, მისი გამოყენება შესაძლებელია ავტობუსში მდებარე ნებისმიერი მოწყობილობის მოსაძებნად. ფუნქცია იღებს სასურველი მოწყობილობის მისამართს და თუ ის პასუხობს, აბრუნებს ნულს. თუ მოწყობილობა ამ მისამართით არ არის ავტობუსში, ის დაგიბრუნებს ერთს.
BYTE pcf8574_byte_out (BYTE მონაცემები, BYTE დამატება) ( BYTE ask = ACK; add &= 0xFE; i2c_start(); ask = i2c_send_byte(add); if(!ask) ask = i2c_send_byte(data); i2c_stop(); )ეს ფუნქცია უკვე გამკაცრდა მხოლოდ ამ ჩიპისთვის. როგორც არგუმენტები, მას გადაეცემა ბაიტი ავტობუსში გადასაცემად და მიკროსქემის მისამართით. ფუნქცია ჯერ ითხოვს ჩიპს მისამართზე და შემდეგ გაგზავნის ბაიტს. თუ ჩიპმა მიიღო ბაიტი და უპასუხა ACK-ით, მაშინ ფუნქცია შეწყვეტს ჩიპს და დააბრუნებს ნულს, როგორც წარმატებულ ბაიტს. და მიკროცირკულა ამ დროს გამოსცემს ამ ბაიტს თავის პარალელურ პორტში. წინააღმდეგ შემთხვევაში, ვიღებთ NACK-ს და ვაბრუნებთ ერთს, გადაცემა ვერ მოხერხდა.
BYTE pcf8574_str_out(BYTE *data, BYTE col, BYTE add) ( BYTE ask = ACK; დამატება &= 0xFE; i2c_start(); ask = i2c_send_byte(add); 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-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(40); // ბრძანების შესრულების დაყოვნება com (0x30); // 4-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(40); // ბრძანების შესრულების დაყოვნება com (0x30); // 4-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(40); // ბრძანების შესრულების დაყოვნება com (0x20); // 4-ბიტიან რეჟიმში გადართვა _ დაგვიანებით_ჩვენ(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 data) ( BYTE data_h = ((data & 0xF0) + 0x09); BYTE data_l = ((data // Pass high 4 bit 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

მძიმით აკლია. სწორია: "HELLO WORLD!" და ეს მოწყობილობა გამკაცრებულია არა მხოლოდ 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 μs პაუზა. იმის გამო, რომ გადარიცხვა გადის 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-საც კი განსხვავებული ასმ აქვთ. ხოლო რაც შეეხება LCD დისპლეის დეტალებს, შეგიძლიათ ნახოთ))) მართალია, CVAVR-ზეც დავწერე, მაგრამ ყველა ბრძანება დალაგდა და დალაგდა. მაგრამ ნებისმიერ შემთხვევაში, თავად გადაწყვიტეთ სად წერია უფრო გარკვევით))) ავტორი წერს, მკითხველი ირჩევს.

GeK 04.01.17 12:52

"I2C ჩიპის მისამართი (ნაგულისხმევი არის 0x4E"

მისამართის ზედა 4 ბიტი ფიქსირდება,
პრეფიქსი PCF8574 არის 0100 და PCF8574A არის 0111
ქვედა 3 ბიტი დამოკიდებულია A2-A0 მიკროსქემის შეყვანის მდგომარეობაზე. ნაგულისხმევად, სამივე ჯემპერი ღიაა, შესაბამისად, მიკროსქემის მისამართია 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
ასე რომ, აქ ყველაფერი სწორია. და თუ თქვენ გჭირდებათ მისამართის შეცვლა, თქვენ უბრალოდ უნდა შეცვალოთ იგი განსაზღვრაში.

იური 14.12.17 21:26

Კარგი დღე! ასევე შეგიძლიათ გამოიყენოთ lcdgotoxy და lcdclear ფუნქციის კოდი PCF8574 ადაპტერთან მუშაობისთვის.

ალექსანდრე 20.05.18 18:14

Კარგი დღე! როგორ აჩვენებთ რუსულ ტექსტს.

ალექსეი 05/20/18 23:04

ეს არის შიდა ჩვენება MELT-ისგან. მას მეხსიერებაში კირიული ანბანი აქვს შეკერილი.

ალექსანდრე 21.05.18 04:55

Კარგი დღე! მე ვწერ ისე, როგორც თქვენ გაქვთ AtmelStudio 6.2-ის პროექტში "ЁPҐBET MҐP!" კარგად გამოდის
და თუ დაწერ "HELLO WORLD!" გამოაქვს ყველანაირი სისულელე. მე მაქვს ორი
ჩვენების ვარიანტი ერთში შეკერილია კირილიცაზე. მეორე ჩინური.

ალექსეი 05/21/18 09:22

ჯერ სატესტო პროგრამას დავწერდი. მთელი მეხსიერების აღრიცხვა სიმბოლოების და მათი მისამართების ჩვენებით. და მერე გაარკვიე რა პრობლემაა. სავარაუდოდ, სიმბოლოების ცხრილი არ ემთხვევა ასციების ცხრილს.

ანდრეი 03.09.18 08:32

Შუადღემშვიდობის!

პროტეუსის სქემას ვერ ატვირთავ?

ანდრეი 03.09.18 10:22

ან პროტეუსში არავინ შემოწმდა?

ანდრეი 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 adr)
{
uint8_t ask = ACK;
addr |= 0b01; //წაიკითხე
uint8_tdata=0;
i2c_start();
ask = i2c_send_byte(addr);
if(!ask) data = i2c_read_byte(NACK);
i2c_stop();

მონაცემების დაბრუნება;
}

პაველი 06/07/19 20:37

რა ღირს, 150 მანეთი, ზოგადად რელეს ფასი), მაგრამ STM-სთვის დაფებს როგორ ამრავლებთ? LUT არასანდოა, CNC როუტერი არ არის დარწმუნებული რა დასჭირდება (არ სცადე)

LCD დისპლეი- ხშირი სტუმარი არდუინოს პროექტებში. მაგრამ რთულ სქემებში შეიძლება გვქონდეს 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;
  • მიწოდების ძაბვა 5V;
  • ფორმატირება 16x2 სიმბოლო;
  • ოპერაციული ტემპერატურის დიაპაზონი -20C-დან +70C-მდე, შენახვის ტემპერატურის დიაპაზონი -30C-დან +80C-მდე;
  • ხედვის კუთხე 180 გრადუსი.

გაყვანილობის დიაგრამა LCD-სთვის Arduino დაფაზე i2C-ის გარეშე

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

დასაკავშირებელი კონტაქტების დიდი რაოდენობის გამო, შეიძლება არ იყოს საკმარისი სივრცე საჭირო ელემენტების დასაკავშირებლად. I2C გამოყენებით ამცირებს მავთულხლართების რაოდენობას 4-მდე და დაკავებული ქინძისთავები 2-მდე.

სად ვიყიდო LCD ეკრანები და ფარები arduino-სთვის

LCD ეკრანი 1602 (და 2004 წლის ვერსია) საკმაოდ პოპულარულია, ასე რომ თქვენ შეგიძლიათ მარტივად იპოვოთ იგი როგორც შიდა ონლაინ მაღაზიებში, ასევე უცხოურ საიტებზე. აქ არის რამდენიმე ბმული ყველაზე ხელმისაწვდომი ვარიანტებისთვის:

LCD1602+I2C ლურჯი ეკრანის მოდული თავსებადი Arduino-სთან მარტივი LCD1602 დისპლეი (მწვანე განათება) 80 რუბლზე იაფი დიდი ეკრანი LCD2004 I2C HD44780 არდუინოსთვის (ლურჯი და მწვანე განათება)
1602 ეკრანი IIC ადაპტერით და ლურჯი შუქით LCD1602-ის კიდევ ერთი ვერსია შედუღებული I2C მოდულით პორტი IIC/I2C/TWI/SPI ადაპტერის მოდული 1602 Shield-ისთვის, თავსებადი Arduino-სთან
RGB განათებული ეკრანი! LCD 16×2 + კლავიატურა + Buzzer Shield Arduino-სთვის ფარი Arduino-სთვის ღილაკებით და ეკრანით LCD1602 LCD 1602 LCD დისპლეი 3D პრინტერისთვის (ჭკვიანი კონტროლერი RAMPS 1.4-ისთვის, ტექსტური LCD 20×4), SD და MicroSD ბარათის წამკითხველის მოდული

I2C პროტოკოლის აღწერა

სანამ i2c ადაპტერის საშუალებით დისპლეის არდუინოსთან დაკავშირებას განვიხილავთ, მოკლედ ვისაუბროთ თავად 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 დისპლეით მუშაობისთვის

Arduino-ს LCD 1602-თან I2C ავტობუსის საშუალებით დასაკავშირებლად, დაგჭირდებათ მინიმუმ ორი ბიბლიოთეკა:

  • Wire.h ბიბლიოთეკა I2C-თან მუშაობისთვის უკვე ხელმისაწვდომია სტანდარტულ Arduino IDE პროგრამაში.
  • LiquidCrystal_I2C.h ბიბლიოთეკა, რომელიც მოიცავს მრავალფეროვან ბრძანებებს მონიტორის I2C ავტობუსით მართვისთვის და საშუალებას გაძლევთ გაამარტივოთ და მოკლე ესკიზი. საჭიროა დამატებით დააინსტალიროთ ბიბლიოთეკა დისპლეის დაკავშირების შემდეგ, დამატებით უნდა დააინსტალიროთ LiquidCrystal_I2C.h ბიბლიოთეკა

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

#შეიცავს #შეიცავს // ბიბლიოთეკის კავშირი //#include // ალტერნატიული ბიბლიოთეკის დაკავშირება LiquidCrystal_I2C lcd(0x27,16,2); ( ) ( lcd.init () გამარჯობა"); // აკრიფეთ ტექსტი პირველ სტრიქონზე 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) ბიტმაპ ბიტმაპების მასივის გამოყენებით შავი და თეთრი წერტილების შესაქმნელად.

ალტერნატიული ბიბლიოთეკა i2c დისპლეით მუშაობისთვის

ზოგიერთ შემთხვევაში, PCF8574 კონტროლერებით აღჭურვილი მოწყობილობებით მითითებული ბიბლიოთეკის გამოყენებისას შეიძლება მოხდეს შეცდომები. ამ შემთხვევაში, LiquidCrystal_PCF8574.h ბიბლიოთეკა შეიძლება იყოს შემოთავაზებული, როგორც ალტერნატივა. ის აფართოებს LiquidCrystal_I2C-ს, ამიტომ მისი გამოყენებისას არანაირი პრობლემა არ უნდა იყოს.

i2c LCD დისპლეის კავშირის პრობლემები

თუ ესკიზის ატვირთვის შემდეგ ეკრანზე ვერაფერს ხედავთ, სცადეთ შემდეგი ნაბიჯები.

პირველ რიგში, შეგიძლიათ გაზარდოთ ან შეამციროთ მონიტორის კონტრასტი. ხშირად პერსონაჟები უბრალოდ არ ჩანს კონტრასტის და განათების რეჟიმის გამო.

თუ ეს არ დაეხმარება, მაშინ შეამოწმეთ კონტაქტების სწორი კავშირი, არის თუ არა შუქნიშანი. თუ იყენებდით ცალკე i2c ადაპტერს, კვლავ შეამოწმეთ კონტაქტების შედუღების ხარისხი.

ეკრანზე ტექსტის ნაკლებობის კიდევ ერთი გავრცელებული მიზეზი შეიძლება იყოს არასწორი i2c მისამართი. ჯერ სცადეთ შეცვალოთ მოწყობილობის მისამართი ესკიზში 0x27 0x20 ან 0x3F. სხვადასხვა მწარმოებელს შეიძლება ჰქონდეს განსხვავებული ნაგულისხმევი მისამართი. თუ ეს არ დაგვეხმარება, შეგიძლიათ გაუშვათ i2c სკანერის ესკიზი, რომელიც სკანირებს ყველა დაკავშირებულ მოწყობილობას და განსაზღვრავს მათ მისამართს უხეში ძალით. i2c სკანერის ესკიზის მაგალითი.

თუ ეკრანი მაინც არ მუშაობს, სცადეთ ადაპტერის გაუქმება და LCD-ის ჩვეული დაკავშირება.

დასკვნა

ამ სტატიაში ჩვენ განვიხილეთ LCD ეკრანის გამოყენების ძირითადი საკითხები Arduino-ს კომპლექსურ პროექტებში, როდესაც გვჭირდება დაფაზე უფასო ქინძისთავების შენახვა. მარტივი და იაფი i2c ადაპტერი საშუალებას მოგცემთ დააკავშიროთ 1602 LCD ეკრანი, რომელიც იკავებს მხოლოდ 2 ანალოგურ პინს. ბევრ სიტუაციაში ეს შეიძლება იყოს ძალიან მნიშვნელოვანი. მოხერხებულობის ფასი არის დამატებითი მოდულის - კონვერტორისა და ბიბლიოთეკის გამოყენების აუცილებლობა. ჩვენი აზრით, ეს არ არის მაღალი ფასი მოხერხებულობისთვის და ჩვენ გირჩევთ გამოიყენოთ ეს ფუნქცია პროექტებში.

ᲓᲐᲙᲐᲕᲨᲘᲠᲔᲑᲣᲚᲘ ᲡᲢᲐᲢᲘᲔᲑᲘ