Introduzione al modulo adattatore LCD I2C

In questo post daremo uno sguardo al modulo adattatore LCD basato su 'I2C' o 'IIC' o 'I quadrato C', che ridurrà i collegamenti tra Arduino e display LCD a soli 2 fili, risparmiando anche tonnellate di pin GPIO per altri sensori / azionamenti ecc.

Prima di discutere del modulo adattatore I2C LCD, è importante capire cos'è il bus I2C e come funziona.

Ma comunque non è necessario essere un esperto con il protocollo I2C per lavorare con questo adattatore LCD menzionato.

Illustrazione della connessione I2C:

I2C o IIC sta per 'Inter-Integrated Circuit' è un bus seriale per computer inventato dai semiconduttori Philips, oggi noto come semiconduttori NXP. Questo sistema di autobus è stato inventato nel 1982.

Cos'è il bus?

Il bus è un gruppo di cavi / fili che trasportano dati da un chip a un altro chip / un circuito stampato a un altro circuito.

Il vantaggio principale del protocollo bus I2C è che il microcontrollore, i sensori oi chip supportati possono essere collegati tra loro con solo due fili. Il vantaggio strabiliante di questo protocollo è che possiamo interconnettere 127 diversi chip o sensori / driver a un dispositivo master che di solito è un microcontrollore con solo 2 fili.

Quali sono i due fili I2C?

I due fili sono SDA e SCL che sono rispettivamente Serial Data e Serial clock.

L'orologio seriale o SCL viene utilizzato per sincronizzare la comunicazione dati sul bus I2C. SDA o Serial Data è la linea dati in cui i dati effettivi vengono convogliati dal master allo slave e viceversa. Il dispositivo master controlla l'orologio seriale e decide per quale dispositivo slave deve comunicare. Nessun dispositivo slave può avviare una comunicazione per primo, solo il dispositivo master può farlo.

La linea dati seriale è bidirezionale e robusta, dopo che ogni set di dati a 8 bit è stato inviato, il dispositivo ricevente invia un bit di riconoscimento.

Quanto è veloce il protocollo I2C?

La versione originale del protocollo I2C sviluppata nel 1982 supportava 100 Kbps. La versione successiva è stata standardizzata nel 1992 che supportava 400 Kbps (modalità veloce) e supportava fino a 1008 dispositivi. La versione successiva è stata sviluppata nel 1998 con 3,4 Mbps (modalità ad alta velocità).

Diverse altre versioni di I2C sono state sviluppate negli anni 2000, 2007, 2012 (con modalità 5Mbps Ultra-Fast) e la versione recente di I2C è stata sviluppata nel 2014.

Perché resistori pull-up nel bus I2C?

SDA e SCL sono 'open-drain', il che significa che entrambe le linee possono andare in BASSO ma non può guidare le linee in ALTO, quindi una resistenza di pull-up è collegata su ciascuna delle linee.

Ma con la maggior parte dei moduli I2C come LCD o RTC sono incorporati resistori di pull up, quindi non è necessario collegarne uno a meno che non sia specificato.

Resistenza di pull-up / pull-down: la resistenza di pull-up è una resistenza collegata alla linea + Ve dell'alimentazione per mantenere il livello logico di una linea su HIGH se la linea non è né alta né bassa.

Un resistore pull-down è un resistore collegato alla linea –Ve dell'alimentazione per mantenere il livello logico di una linea su BASSO se la linea non è né alta né bassa.

Ciò impedisce anche che il rumore entri nelle linee.

Speriamo di aver scalfito la superficie del protocollo I2C, se hai bisogno di maggiori informazioni sul protocollo I2C, naviga su

YouTube e Google.

Ora diamo un'occhiata al modulo LCD I2C:

Sono presenti 16 pin di uscita per il display LCD che possono essere saldati direttamente sul retro del modulo LCD 16 x 2.

I pin di ingresso sono + 5V, GND, SDA e SCL. I pin SDA e SCL su Arduino Uno sono rispettivamente i pin A4 e A5. Per Arduino, mega SDA è il pin # 20 e SCL è il pin # 21.

Confrontiamo come appare quando colleghiamo l'LCD ad Arduino senza l'adattatore I2C e con l'adattatore.

Senza adattatore I2C:

Con adattatore I2C:

L'adattatore è saldato sul retro del display LCD e, come possiamo vedere, abbiamo salvato un sacco di pin GPIO per altre attività e inoltre possiamo continuare ad aggiungere altri 126 dispositivi I2C ai pin A4 e A5.

Tieni presente che la libreria Liquid Crystal standard non funziona con questo adattatore LCD I2C, c'è una libreria speciale per questo, che sarà trattata presto e ti mostreremo come utilizzare questo modulo con un esempio di codifica.

Come collegare l'adattatore I2C a un display 16 x 2

Nelle sezioni precedenti dell'articolo abbiamo appreso le basi del protocollo I2C e abbiamo fornito una panoramica di base sul modulo adattatore LCD I2C. In questo post impareremo come collegare il modulo adattatore LCD I2C al display LCD 16 x 2 e vedremo come programmare con un esempio.

Il principale vantaggio del protocollo I2C è che possiamo collegare i sensori / dispositivi di input / output supportati in sole due linee ed è utile con Arduino in quanto ha pin GPIO limitati.

Ora vediamo come collegare il modulo all'LCD.

Il modulo ha 16 pin di uscita e 4 pin di ingresso. Possiamo semplicemente saldare l'adattatore sul retro del display LCD 16 x 2. Dei 4 pin di ingresso, i due sono + 5V e GND, gli altri due sono SDA e SCL.

Possiamo vedere che abbiamo salvato molti pin su Arduino per altre attività di input / output.

Possiamo regolare il contrasto del display agendo sul potenziometro con un piccolo cacciavite (evidenziato nel riquadro rosso).

La retroilluminazione ora può essere controllata nel codice del programma stesso:

lcd.backlight ()

Questo attiverà la retroilluminazione del display LCD.

lcd.noBacklight ()

Questo spegnerà la retroilluminazione del display LCD.

Possiamo vedere che c'è un jumper collegato, che è evidenziato nel riquadro rosso, se il jumper viene rimosso la retroilluminazione rimane spenta indipendentemente dal comando del programma.

Ora la configurazione dell'hardware è terminata, ora vediamo come programmare. Ricorda che il modulo LCD I2C necessita di particolari

library e la libreria preinstallata 'liquidcrystal' non funzioneranno.

Puoi scaricare la libreria I2C LCD da qui e aggiungerla all'IDE di Arduino:

github.com/marcoschwartz/LiquidCrystal_I2C

Dal post precedente abbiamo appreso che i dispositivi I2C hanno un indirizzo tramite il quale il master o il microcontrollore possono identificare il dispositivo e comunicare.

Nella maggior parte dei casi, per il modulo LCD I2C l'indirizzo sarebbe '0x27'. Ma una produzione diversa può avere un indirizzo diverso. Dobbiamo inserire l'indirizzo corretto nel programma solo allora il display LCD funzionerà.

Per trovare l'indirizzo basta collegare 5V a Vcc e GND a GND di Arduino e il pin SCL del modulo I2C ad A5 e SDA ad A4 e caricare il codice sottostante.

Questo eseguirà la scansione dei dispositivi I2C collegati e mostrerà il loro indirizzo.

// -------------------------------- //
#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)
}
// -------------------------------- //

Carica il codice e apri il monitor seriale.

Come possiamo vedere, sono stati rilevati due dispositivi e vengono visualizzati i loro indirizzi, ma se si desidera trovare solo l'indirizzo del modulo LCD I2C, non collegare altri dispositivi I2C durante la scansione.
Quindi in conclusione abbiamo ottenuto l'indirizzo '0x27'.

Ora realizzeremo un orologio digitale come esempio perché ci sono due dispositivi I2C, il modulo LCD e il modulo RTC o orologio in tempo reale. Entrambi i moduli saranno collegati con due fili.

Scarica la seguente libreria:
Libreria RTC: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Come impostare l'ora su RTC

• Apri Arduino IDE e vai su File> Esempio> DS1307RTC> imposta ora.
• Carica il codice con l'hardware completo e apri il monitor seriale e hai finito.

Schema elettrico:

Programma:

//------------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-------//

Nota:

LiquidCrystal_I2C lcd (0x27, 16, 2)

Lo '0x27' è l'indirizzo che abbiamo trovato scansionando e 16 e 2 sono il numero di righe e colonne sul display LCD.

Per RTC non abbiamo bisogno di trovare l'indirizzo ma abbiamo trovato durante la scansione “0x68”, ma comunque la libreria RTC lo gestirà.

Ora vediamo quanto abbiamo ridotto la congestione del cavo e salvato i pin GPIO su Arduino.

Solo 4 fili sono collegati al display LCD, evidenziato in un riquadro rosso.

Inoltre solo 4 fili sono collegati da Arduino e il modulo RTC condivide le stesse linee.

Ormai hai acquisito le conoscenze di base su I2C e su come utilizzare il modulo adattatore LCD I2C.
Ti piace questo post? Avete domande? Si prega di esprimere nella sezione commenti, potresti ottenere una risposta rapida.