Panimula sa I2C LCD Adapter Module

Sa post na ito titingnan namin ang 'I2C' o 'IIC' o 'I square C' batay sa module ng LCD adapter, na magbabawas ng mga koneksyon sa wire sa pagitan ng Arduino at LCD display sa 2 wires lamang, nagse-save din ng tonelada ng mga GPIO pin para sa iba pang mga sensor / drive atbp.

Bago namin talakayin ang tungkol sa I2C LCD adapter module, mahalagang maunawaan kung ano ang I2C bus at kung paano ito gumagana.

Ngunit gayon pa man hindi mo kailangan na maging isang dalubhasa sa I2C protocol upang gumana sa pagbanggit ng LCD adapter.

Paglalarawan ng koneksyon ng I2C:

Ang I2C o IIC ay nangangahulugang 'Inter-Integrated Circuit' ay isang serial computer bus na naimbento ng Philips semiconductors, na kilala ngayon bilang NXP semiconductors. Ang sistema ng bus na ito ay naimbento noong 1982.

Ano ang Bus?

Ang bus ay isang pangkat ng mga cable / wires na nagdadala ng data mula sa isang maliit na tilad patungo sa isa pang maliit na tilad / isang circuit board patungo sa isa pang circuit board.

Ang pangunahing bentahe ng I2C bus protocol ay iyon, ang sinusuportahang microcontroller o mga sensor o chips ay maaaring maiugnay sa dalawang wires lamang. Ang bentahe ng pag-iisip ng isip ng protokol na ito ay, maaari naming magkaugnay sa 127 iba't ibang mga chips o sensor / driver sa isang master device na karaniwang isang microcontroller na may 2 wires lamang.

Ano ang dalawang wires ng I2C?

Ang dalawang wires ay ang SDA at SCL na kung saan ay Serial Data at Serial na orasan ayon sa pagkakabanggit.

Ginagamit ang Serial na orasan o SCL upang mai-sync ang komunikasyon ng data sa I2C bus. Ang SDA o Serial Data ay ang linya ng data kung saan ang tunay na data ay naihatid mula sa master hanggang sa alipin at kabaligtaran. Kinokontrol ng master device ang Serial na orasan at nagpasya kung aling alipin ang aparato na kailangan nito upang makipag-usap. Walang alipin na aparato ang maaaring magpasimula ng isang komunikasyon muna, ang master aparato lamang ang makakagawa.

Ang linya ng data ng Serial ay pantulong at matatag, pagkatapos ng bawat hanay ng 8 bit na data ay naipadala, ang tumatanggap na aparato ay nagpapadala ng isang bit ng pagkilala.

Gaano kabilis ang I2C protocol?

Ang orihinal na bersyon ng I2C protocol na binuo noong 1982 ay suportado ng 100 Kbps. Ang susunod na bersyon ay na-standardize noong 1992 na sumusuporta sa 400Kbps (Mabilis na mode) at suportado ng hanggang sa 1008 na mga aparato. Ang susunod na bersyon ay binuo noong 1998 na may 3.4 Mbps (High speed mode).

Maraming iba pang mga bersyon ng I2C ang binuo noong taon 2000, 2007, 2012 (na may 5Mbps Ultra-Fast mode) at ang pinakabagong bersyon ng I2C ay binuo noong 2014.

Bakit ang mga pull-up resistor sa I2C bus?

Ang SDA at SCL ay 'open-drain' na nangangahulugang ang parehong mga linya ay maaaring maging LOW ngunit hindi nito maaaring himukin ang mga linya ng TAAS, kaya ang isang pull-up risistor ay konektado sa bawat linya.

Ngunit sa karamihan ng mga module ng I2C tulad ng LCD o RTC ay nakabuo ng mga pull up resistor, kaya hindi namin kailangang ikonekta ang isa maliban kung ito ay tinukoy.

Pull-up / Pull-down na risistor: Ang pull-up risistor ay isang risistor na konektado sa + Ve na linya ng supply upang mapanatili ang antas ng lohika ng isang linya sa TAAS kung ang linya ay hindi mataas o mababa.

Ang isang pull-down risistor ay isang risistor na konektado sa –Ve na linya ng supply upang mapanatili ang antas ng lohika ng isang linya sa LOW kung ang linya ay hindi mataas o mababa.

Pinipigilan din nito ang pagpasok ng ingay sa mga linya.

Inaasahan namin na napakamot namin ang ibabaw ng I2C protocol, kung kailangan mo ng karagdagang impormasyon sa I2C protocol, mangyaring mag-surf sa

YouTube at Google.

Tingnan natin ang module ng I2C LCD:

Mayroong 16 output pin para sa LCD display na maaaring soldered nang direkta sa likuran ng 16 X 2 LCD module.

Ang mga input pin ay + 5V, GND, SDA at SCL. Ang mga SDA at SCL na pin sa Arduino Uno ay mga pin na A4 at A5 ayon sa pagkakabanggit. Para sa Arduino mega SDA ay pin # 20 at ang SCL ay pin # 21.

Paghambingin natin kung ano ang hitsura nito kapag sinambay natin ang LCD sa Arduino nang walang I2C adapter at sa adapter.

Nang walang I2C Adapter:

Sa I2C adapter:

Ang Adapter ay solder sa likod ng display ng LCD at tulad ng nakikita natin na naka-save kami ng maraming mga GPIO pin para sa iba pang mga gawain at maaari rin naming magpatuloy na magdagdag ng 126 pang mga aparato ng I2C sa mga pin na A4 at A5.

Mangyaring tandaan na ang standard na library ng Liquid Crystal ay hindi gagana sa I2C LCD adapter na ito, mayroong isang espesyal na silid-aklatan para dito, na sasakupin sa lalong madaling panahon at ipapakita namin sa iyo kung paano gamitin ang modyul na ito sa halimbawa ng pag-coding.

Paano Ikonekta ang I2C Adapter sa 16 x 2 Display

Sa mga seksyon sa itaas ng artikulo natutunan namin ang mga pangunahing kaalaman ng I2C protocol at kumuha ng isang pangunahing pangkalahatang ideya sa I2C LCD adapter module. Sa post na ito matututunan namin kung paano ikonekta ang I2C LCD adapter module sa 16 x 2 LCD display at makikita natin kung paano ang programa sa isang halimbawa.

Ang pangunahing bentahe ng I2C protocol ay maaari nating i-wire ang mga suportadong sensor / input / output na aparato sa dalawang linya lamang at kapaki-pakinabang sa Arduino dahil limitado ang mga GPIO na pin.

Tingnan natin ngayon kung paano ikonekta ang module sa LCD.

Ang module ay may 16 output pin at 4 na input pin. Maaari lamang kaming maghinang ng adapter sa likuran ng 16 x 2 LCD display. Sa labas ng 4 na input pin, ang dalawa ay + 5V at GND, ang natitirang dalawa ay SDA at SCL.

Maaari naming makita na naka-save kami ng maraming mga pin sa Arduino para sa iba pang mga gawain sa pag-input / output.

Maaari naming ayusin ang kaibahan ng display sa pamamagitan ng pag-aayos ng potensyomiter sa maliit na driver ng tornilyo (naka-highlight sa pulang kahon).

Ang backlighting ngayon ay maaaring makontrol sa program code mismo:

lcd.backlight ()

Bubuksan nito ang backlight sa LCD display.

lcd.noBacklight ()

Ito ay papatayin ang backlight sa LCD display.

Maaari naming makita na mayroong koneksyon ng jumper, na naka-highlight sa pulang kahon, kung ang jumper ay tinanggal ang backlight ay mananatiling OFF anuman ang utos ng programa.

Ngayon ay tapos na ang pag-setup ng hardware, tingnan natin ngayon kung paano mag-code. Mangyaring tandaan na ang I2C LCD module ay nangangailangan ng espesyal

hindi gagana ang library at ang paunang naka-install na librong 'liquidcrystal'.

Maaari mong i-download ang I2C LCD library mula rito at idagdag sa Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

Mula sa nakaraang post natutunan namin na ang mga aparato ng I2C ay may address kung saan maaaring makilala ng master o ng microcontroller ang aparato at makipag-usap.

Sa karamihan ng kaso, para sa module na I2C LCD ang address ay magiging '0x27'. Ngunit ang magkakaibang paggawa ay maaaring may iba't ibang address. Kailangan naming ipasok ang tamang address sa programa lamang pagkatapos ay gagana ang iyong LCD display.

Upang hanapin ang address ay ikonekta lamang ang 5V sa Vcc at GND sa GND ng Arduino at SCL pin ng I2C module sa A5 at SDA sa A4 at i-upload ang code sa ibaba.

I-scan nito ang mga nakakonektang aparato ng I2C at ipapakita ang kanilang address.

// -------------------------------- //
#include
void setup()
{
Wire.begin()
Serial.begin(9600)
while (!Serial)
Serial.println('-----------------------')
Serial.println('I2C Device Scanner')
Serial.println('-----------------------')
}
void loop()
{
byte error
byte address
int Devices
Serial.println('Scanning...')
Devices = 0
for (address = 1 address <127 address++ )
{
Wire.beginTransmission(address)
error = Wire.endTransmission()
if (error == 0)
{
Serial.print('I2C device found at address 0x')
if (address <16)
{
Serial.print('0')
}
Serial.print(address, HEX)
Serial.println(' !')
Devices++
}
else if (error == 4)
{
Serial.print('Unknown error at address 0x')
if (address <16)
Serial.print('0')
Serial.println(address, HEX)
}
}
if (Devices == 0)
{
Serial.println('No I2C devices found ')
}
else
{
Serial.println('-------------- done -------------')
Serial.println('')
}
delay(5000)
}
// -------------------------------- //

I-upload ang code at buksan ang serial monitor.

Tulad ng nakikita natin ang dalawang mga aparato ay napansin at ang kanilang mga address ay ipinakita, ngunit kung nais mong hanapin lamang ang address ng I2C LCD module, hindi mo dapat ikonekta ang anumang iba pang mga aparato ng I2C habang ini-scan.
Kaya sa pagtatapos nakuha namin ang address na '0x27'.

Ngayon ay gagawa kami ng isang digital na relo bilang halimbawa dahil mayroong dalawang mga aparato ng I2C, ang module ng LCD at RTC o module ng real time na orasan. Ang parehong mga module ay konektado sa dalawang mga wire.

I-download ang sumusunod na library:
RTC library: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Paano magtakda ng oras sa RTC

• Buksan ang Arduino IDE at mag-navigate sa File> Halimbawa> DS1307RTC> itinakdang oras.
• I-upload ang code na may nakumpleto na hardware at buksan ang serial monitor at tapos ka na.

Diagram ng circuit:

Programa:

//------------Program Developed by R.Girish-------//
#include
#include
#include
#include
LiquidCrystal_I2C lcd(0x27, 16, 2)
void setup()
{
lcd.init()
lcd.backlight()
}
void loop()
{
tmElements_t tm
lcd.clear()
if (RTC.read(tm))
{
if (tm.Hour >= 12)
{
lcd.setCursor(14, 0)
lcd.print('PM')
}
if (tm.Hour <12)
{
lcd.setCursor(14, 0)
lcd.print('AM')
}
lcd.setCursor(0, 0)
lcd.print('TIME:')
if (tm.Hour > 12)
{
if (tm.Hour == 13) lcd.print('01')
if (tm.Hour == 14) lcd.print('02')
if (tm.Hour == 15) lcd.print('03')
if (tm.Hour == 16) lcd.print('04')
if (tm.Hour == 17) lcd.print('05')
if (tm.Hour == 18) lcd.print('06')
if (tm.Hour == 19) lcd.print('07')
if (tm.Hour == 20) lcd.print('08')
if (tm.Hour == 21) lcd.print('09')
if (tm.Hour == 22) lcd.print('10')
if (tm.Hour == 23) lcd.print('11')
}
else
{
lcd.print(tm.Hour)
}
lcd.print(':')
lcd.print(tm.Minute)
lcd.print(':')
lcd.print(tm.Second)
lcd.setCursor(0, 1)
lcd.print('DATE:')
lcd.print(tm.Day)
lcd.print('/')
lcd.print(tm.Month)
lcd.print('/')
lcd.print(tmYearToCalendar(tm.Year))
} else {
if (RTC.chipPresent())
{
lcd.setCursor(0, 0)
lcd.print('RTC stopped!!!')
lcd.setCursor(0, 1)
lcd.print('Run SetTime code')
} else {
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Read error!')
lcd.setCursor(0, 1)
lcd.print('Check circuitry!')
}
}
delay(1000)
}
//------------Program Developed by R.Girish-------//

Tandaan:

LiquidCrystal_I2C lcd (0x27, 16, 2)

Ang '0x27' ay ang address na nakita namin sa pamamagitan ng pag-scan at 16 at 2 ang bilang ng mga hilera at haligi sa LCD display.

Para sa RTC hindi namin kailangang hanapin ang address ngunit nahanap namin habang ini-scan ang '0x68', ngunit gayon pa man ang RTC library ang hahawak nito.

Tingnan natin ngayon kung gaano natin binawasan ang kasikipan ng kawad at nai-save ang mga GPIO pin sa Arduino.

4 na wires lamang ang nakakonekta sa LCD display, naka-highlight sa pulang kahon.

Gayundin ang 4 na mga wire ay konektado mula sa Arduino at ang module ng RTC ay nagbabahagi ng parehong mga linya.

Sa ngayon nakakuha ka ng pangunahing kaalaman sa I2C at kung paano gamitin ang I2C LCD adapter module.
Gusto mo ba ng post na ito? Mayroon ka bang mga katanungan? Mangyaring ipahayag sa seksyon ng komento, maaari kang makakuha ng isang mabilis na tugon.