Introduction au module adaptateur LCD I2C

Dans cet article, nous allons jeter un coup d'œil au module adaptateur LCD basé sur «I2C» ou «IIC» ou «I square C», qui réduira les connexions de fil entre Arduino et l'écran LCD à seulement 2 fils, économisant également des tonnes de broches GPIO pour autres capteurs / lecteurs, etc.

Avant de discuter du module adaptateur LCD I2C, il est important de comprendre ce qu'est le bus I2C et comment il fonctionne.

Mais de toute façon, vous n'avez pas besoin d'être un expert du protocole I2C pour travailler avec cet adaptateur LCD.

Illustration de la connexion I2C:

L'I2C ou IIC signifie «Inter-Integrated Circuit» est un bus informatique série inventé par Philips semi-conducteurs, aujourd'hui connu sous le nom de semi-conducteurs NXP. Ce système de bus a été inventé en 1982.

Qu'est-ce que le bus?

Le bus est un groupe de câbles / fils qui transportent des données d'une puce à une autre puce / d'une carte de circuit imprimé à une autre carte de circuit imprimé.

Le principal avantage du protocole de bus I2C est que le microcontrôleur ou les capteurs ou puces pris en charge peuvent être interconnectés avec seulement deux fils. L'avantage époustouflant de ce protocole est que nous pouvons interconnecter 127 puces ou capteurs / pilotes différents à un appareil maître qui est généralement un microcontrôleur avec seulement 2 fils.

Quels sont les deux fils I2C?

Les deux fils sont SDA et SCL qui sont respectivement des données série et une horloge série.

L'horloge série ou SCL est utilisée pour synchroniser la communication de données sur le bus I2C. Le SDA ou Serial Data est la ligne de données dans laquelle les données réelles sont transmises du maître à l'esclave et vice versa. Le dispositif maître contrôle l'horloge série et décide pour quel dispositif esclave il doit communiquer. Aucun appareil esclave ne peut initier une communication en premier, seul l'appareil maître peut le faire.

La ligne de données série est bidirectionnelle et robuste, après l'envoi de chaque ensemble de données 8 bits, le dispositif récepteur renvoie un bit d'accusé de réception.

Quelle est la vitesse du protocole I2C?

La version originale du protocole I2C développé en 1982 supportait 100 Kbps. La version suivante a été normalisée en 1992, prenant en charge 400 Kbps (mode rapide) et prenant en charge jusqu'à 1008 appareils. La version suivante a été développée en 1998 avec 3,4 Mbps (mode haut débit).

Plusieurs autres versions I2C ont été développées dans les années 2000, 2007, 2012 (avec le mode Ultra-Fast 5Mbps) et la version récente d'I2C a été développée en 2014.

Pourquoi des résistances pull-up dans le bus I2C?

Le SDA et le SCL sont «à drain ouvert», ce qui signifie que les deux lignes peuvent passer à l'état BAS mais ne peuvent pas conduire les lignes à HAUT, donc une résistance de rappel est connectée sur chacune des lignes.

Mais avec la plupart des modules I2C tels que LCD ou RTC ont des résistances de rappel intégrées, nous n'avons donc pas besoin d'en connecter une à moins que cela ne soit spécifié.

Résistance pull-up / pull-down: La résistance pull-up est une résistance connectée à la ligne + Ve de l'alimentation pour maintenir le niveau logique d'une ligne à HIGH si la ligne n'est ni haute ni basse.

Une résistance pull-down est une résistance connectée à la ligne –Ve de l'alimentation pour maintenir le niveau logique d'une ligne sur BAS si la ligne n'est ni haute ni basse.

Cela empêche également le bruit de pénétrer dans les lignes.

Nous espérons que nous avons gratté la surface du protocole I2C, si vous avez besoin de plus d'informations sur le protocole I2C, veuillez surfer sur

YouTube et Google.

Voyons maintenant le module LCD I2C:

Il y a 16 broches de sortie pour l'écran LCD qui peuvent être soudées directement à l'arrière du module LCD 16 X 2.

Les broches d'entrée sont + 5V, GND, SDA et SCL. Les broches SDA et SCL sur Arduino Uno sont respectivement les broches A4 et A5. Pour Arduino mega SDA est la broche n ° 20 et SCL est la broche n ° 21.

Comparons à quoi cela ressemble lorsque nous câblons l'écran LCD à Arduino sans l'adaptateur I2C et avec l'adaptateur.

Sans adaptateur I2C:

Avec adaptateur I2C:

L'adaptateur est soudé à l'arrière de l'écran LCD et comme nous pouvons le voir, nous avons enregistré des tonnes de broches GPIO pour d'autres tâches et nous pouvons également continuer à ajouter 126 périphériques I2C supplémentaires aux broches A4 et A5.

Veuillez noter que la bibliothèque Liquid Crystal standard ne fonctionnera pas avec cet adaptateur LCD I2C, il existe une bibliothèque spéciale pour cela, qui sera bientôt couverte et nous vous montrerons comment utiliser ce module avec un exemple de codage.

Comment connecter l'adaptateur I2C à un écran 16 x 2

Dans les sections ci-dessus de l'article, nous avons appris les bases du protocole I2C et pris un aperçu de base du module adaptateur LCD I2C. Dans cet article, nous allons apprendre comment connecter le module adaptateur LCD I2C à un écran LCD 16 x 2 et nous verrons comment programmer avec un exemple.

Le principal avantage du protocole I2C est que nous pouvons câbler les capteurs / périphériques d'entrée / sortie pris en charge en seulement deux lignes et il est utile avec Arduino car il a des broches GPIO limitées.

Voyons maintenant comment connecter le module à l’écran LCD.

Le module a 16 broches de sortie et 4 broches d'entrée. Nous pouvons simplement souder l'adaptateur à l'arrière de l'écran LCD 16 x 2. Sur les 4 broches d'entrée, les deux sont + 5V et GND, le reste des deux sont SDA et SCL.

Nous pouvons voir que nous avons enregistré beaucoup de broches chez Arduino pour d'autres tâches d'entrée / sortie.

Nous pouvons régler le contraste de l'écran en ajustant le potentiomètre avec un petit tournevis (surligné en rouge).

Le rétroéclairage peut maintenant être contrôlé dans le code du programme lui-même:

LCD rétro-éclairage()

Cela activera le rétroéclairage de l'écran LCD.

lcd.noBacklight ()

Cela désactivera le rétroéclairage de l'écran LCD.

Nous pouvons voir qu'il y a un cavalier connecté, qui est mis en évidence dans la case rouge, si le cavalier est retiré, le rétroéclairage reste éteint quelle que soit la commande du programme.

Maintenant que la configuration matérielle est terminée, voyons maintenant comment coder. N'oubliez pas que le module LCD I2C nécessite des

la bibliothèque et la bibliothèque préinstallée «liquidcrystal» ne fonctionneront pas.

Vous pouvez télécharger la bibliothèque LCD I2C à partir d'ici et l'ajouter à Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

Dans le post précédent, nous avons appris que les périphériques I2C ont une adresse par laquelle le maître ou le microcontrôleur peut identifier le périphérique et communiquer.

Dans la plupart des cas, pour le module LCD I2C, l'adresse serait «0x27». Mais une fabrication différente peut avoir une adresse différente. Nous devons entrer la bonne adresse dans le programme seulement alors votre écran LCD fonctionnera.

Pour trouver l'adresse, connectez simplement 5V à Vcc et GND à GND de Arduino et la broche SCL du module I2C à A5 et SDA à A4 et téléchargez le code ci-dessous.

Cela analysera les périphériques I2C connectés et affichera leur adresse.

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

Téléchargez le code et ouvrez le moniteur série.

Comme nous pouvons le voir, deux périphériques ont été détectés et leurs adresses sont affichées, mais si vous souhaitez trouver uniquement l'adresse du module LCD I2C, vous ne devez connecter aucun autre périphérique I2C pendant la numérisation.
Donc, en conclusion, nous avons obtenu l'adresse «0x27».

Nous allons maintenant faire une montre numérique à titre d'exemple car il y a deux appareils I2C, le module LCD et le module RTC ou horloge temps réel. Les deux modules seront connectés avec deux fils.

Téléchargez la bibliothèque suivante:
Bibliothèque RTC: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Comment régler l'heure sur RTC

• Ouvrez Arduino IDE et accédez à Fichier> Exemple> DS1307RTC> régler l'heure.
• Téléchargez le code avec le matériel terminé et ouvrez le moniteur série et vous avez terminé.

Schéma:

Programme:

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

Noter:

LCD LiquidCrystal_I2C (0x27, 16, 2)

Le «0x27» est l'adresse que nous avons trouvée en scannant et 16 et 2 sont le nombre de lignes et de colonnes sur l'écran LCD.

Pour RTC, nous n'avons pas besoin de trouver l'adresse mais nous l'avons trouvée en scannant «0x68», mais de toute façon la bibliothèque RTC la gérera.

Voyons maintenant à quel point nous avons réduit la congestion des câbles et enregistré les broches GPIO sur Arduino.

Seuls 4 fils sont connectés à l'écran LCD, mis en évidence dans la case rouge.

De plus, seuls 4 fils sont connectés à partir d'Arduino et le module RTC partage les mêmes lignes.

Vous avez maintenant acquis des connaissances de base sur I2C et comment utiliser le module adaptateur LCD I2C.
Aimez-vous cette publication? Avez-vous des questions? Veuillez exprimer dans la section des commentaires, vous pouvez obtenir une réponse rapide.