Présentation et Fonctionnalités du Shield LCD 1602 avec Clavier

Sommaire

Présentation du Shield Écran LCD 1602 avec Clavier

Dans ce tutoriel, nous allons découvrir comment utiliser le shield écran LCD 1602 avec clavier intégré (aussi appelé “keypad”). Ce shield est un module pratique équipé :

  • d’un écran LCD avec une résolution de 16 colonnes et 2 lignes (d’où la désignation 1602),
  • de 6 boutons poussoirs pour interagir avec le système.

Il offre de nombreuses fonctionnalités intéressantes, notamment :

  • Afficher des lettres (minuscules et majuscules) comme : a, b, C, D, e, F.
  • Afficher des chiffres : 1, 2, 4, 5, 6, 7…
  • Faire défiler du texte ou des caractères sur l’écran.
  • Effacer des lignes de texte pour une mise à jour dynamique.
  • Régler le rétroéclairage pour améliorer la visibilité.

Grâce à ce guide, vous apprendrez à exploiter toutes ces fonctionnalités de manière pratique et efficace.

Présentation du shield LCD 1602 keypad
Présentation du shield LCD 1602 keypad

Voici les éléments principaux du shield LCD 1602 avec clavier :

  1. Réglage de la luminosité de l’écran : Permet d’ajuster l’intensité du rétroéclairage pour une meilleure visibilité.
  2. Connecteur des broches numériques (D0 à D6) : Utilisé pour connecter le shield à d’autres composants électroniques.
  3. Écran LCD 16 x 2 lignes : Affiche des caractères ou des messages sur deux lignes de 16 colonnes.
  4. Bouton “SELECT” : Sert à valider ou sélectionner une option dans le programme.
  5. Bouton “LEFT” (Gauche) : Permet de naviguer vers la gauche dans un menu ou une interface.
  6. Bouton “DOWN” (Bas) : Utilisé pour descendre dans une liste ou un menu.
  7. Bouton “UP” (Haut) : Utilisé pour monter dans une liste ou un menu.
  8. Bouton “RIGHT” (Droite) : Permet de naviguer vers la droite dans une interface.
  9. Bouton “RST” (Reset) : Réinitialise le programme chargé sur la carte Arduino.
  10. Connecteur d’alimentation : Point d’entrée pour alimenter le shield et l’écran.
  11. Connecteur des broches analogiques (A0 à A5) : Utilisé pour des connexions analogiques avec d’autres composants.

Utiliser le Shield LCD 1602 + Clavier

Pour mieux comprendre les possibilités offertes par le shield LCD 1602 avec clavier, nous vous proposons deux exemples d’utilisation. Ces exemples pratiques vous guideront étape par étape pour exploiter les fonctionnalités principales du module :

  1. Un premier exemple simple pour débuter avec les bases.
  2. Un deuxième exemple avancé pour explorer des fonctionnalités plus complexes.

Ces cas d’utilisation vous permettront de maîtriser rapidement le shield et de l’intégrer efficacement dans vos projets Arduino.

Affichage Simple avec le Shield LCD 1602 et Arduino UNO

Dans cet exemple, nous allons explorer les fonctionnalités de base du shield écran LCD 1602 avec clavier en utilisant une carte Arduino UNO. Ce programme simple vous permettra de :

  • Afficher des caractères sur l’écran,
  • Naviguer à l’aide des boutons poussoirs,
  • Tester les fonctionnalités essentielles du shield.

Cet exercice est idéal pour se familiariser avec le fonctionnement de ce module et poser les bases pour des projets plus complexes.

Le Programme Arduino

				
					/*Programme: Shield LCD 1602 + Keypad Arduino
 * Auteur: Christian Joseph
 * Date: 22/11/2024
 * Help: contact@atelierdelarobotique.fr
 */

#include <LiquidCrystal.h>
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);// Configuration des ports de l'écran

// Variables
int lcd_key     = 0;
int adc_key_in  = 0;

// Création des boutons
#define btnRIGHT  0
#define btnUP     1
#define btnDOWN   2
#define btnLEFT   3
#define btnSELECT 4
#define btnNONE   5

void setup()
{
 lcd.begin(16, 2);              // Initialisation de l'écran
 lcd.setCursor(0,0);            // Curseur au début de la 1ère ligne
 lcd.print("AtelierRobotique"); // Affichage du Message
}
 
void loop()
{
 lcd.setCursor(0,1);            //Curseur au début de la 2eme ligne
 lcd_key = read_LCD_buttons();  // Lecture des touches

 switch (lcd_key)               // Action en cas de touche pressée
 {
   case btnRIGHT:
     {
     lcd.print("DROITE");
     break;
     }
   case btnLEFT:
     {
     lcd.print("GAUCHE");
     break;
     }
   case btnUP:
     {
     lcd.print("HAUT  ");
     break;
     }
   case btnDOWN:
     {
     lcd.print("BAS   ");
     break;
     }
   case btnSELECT:
     {
     lcd.print("SELECT");
     break;
     }
     case btnNONE:
     {
     lcd.print("      ");// On efface l'écran
     break;
     }
 }
}

// Fonction de lecture des touches
int read_LCD_buttons()
{
 adc_key_in = analogRead(0);   // Lecture du port analogique A0
 if (adc_key_in > 1000) return btnNONE;   
 if (adc_key_in < 50)   return btnRIGHT;     
 if (adc_key_in < 195)  return btnUP;        
 if (adc_key_in < 380)  return btnDOWN;      
 if (adc_key_in < 555)  return btnLEFT;      
 if (adc_key_in < 790)  return btnSELECT;    

 return btnNONE;
}
				
			

Aperçu du Résultat sur l’Écran LCD

Shield LCD1602 + clavier Arduino
Test du shield LCD1602 + clavier
Shield LCD1602 Clavier Arduino
Shield LCD1602 Clavier Arduino - Bouton HAUT
Shield écran LCD1602 Clavier Arduino
Shield LCD1602 Clavier Arduino - Bouton GAUCHE
Shield LCD 1602+ keypad
Shield LCD1602 Clavier Arduino - Bouton DROITE
LCD1602 2x16 lignes Arduino + clavier
Shield LCD1602 Clavier Arduino - Bouton BAS

Construire un Radar avec Affichage LCD 1602 avec Clavier et Capteur Ultrason HC-SR04

Dans ce deuxième exemple, nous allons concevoir un radar orientable capable de mesurer des distances grâce au capteur ultrasonique HC-SR04. Les mesures seront affichées en temps réel sur le shield écran LCD 1602.

Pour cela, le capteur sera monté sur un support pan-tilt équipé de servomoteurs SG90, permettant un balayage horizontal et vertical. Ce projet vous permettra d’explorer des fonctionnalités avancées du shield et d’appliquer des concepts d’interaction entre plusieurs composants électroniques.

Matériel requis

Pour réaliser ce projet de radar avec affichage sur le shield LCD 1602, voici la liste des composants nécessaires :

  1. 1 x Carte Arduino UNO : Le microcontrôleur principal pour gérer le projet.
  2. 1 x Shield LCD 1602 Keypad : Pour afficher les mesures et interagir avec le système via les boutons.
  3. 1 x Capteur à ultrasons HC-SR04 : Pour mesurer les distances grâce aux ultrasons.
  4. 1 x Contrôleur de servomoteurs 16 canaux I2C PCA9685 : Permet de gérer les servomoteurs via le protocole I2C.
  5. 2 x Servomoteurs SG90 : Utilisés pour orienter le capteur HC-SR04 (mouvement horizontal et vertical).
  6. 1 x Support PAN-TILT pour caméras et capteurs : Support mécanique pour fixer le capteur et permettre son orientation.
  7. 1 x Coupleur de piles 18650 (taille 2) : Pour alimenter le projet de manière autonome.
  8. 2 x Piles 3.7V 18650 : Source d’alimentation pour la carte Arduino et les servomoteurs.
  9. 1 x Lot de câbles dupont femelle-femelle (20 cm) : Pour connecter les composants entre eux facilement.

Guide de Montage Électronique pour le Radar Arduino

Schéma de montage Radar Arduino avec le shield LCD 1602 Keypad
Schéma de montage Radar Arduino avec le shield LCD 1602 Keypad
Shield LCD1602 KEYPAD Contrôleur de Servo PCA9685 Capteur à ultrasons
HC-SR04
Coupleur de piles 18650
5V VCC VCC  
GND GND GND Fil Noir
A4 SDA    
A5 SCL    
D2   ECHO  
D3   TRIG  
  V+   Fil Rouge
Branchement des Servomoteurs S1 et S2 :

Les connexions des servomoteurs SG90 (S1 et S2) au contrôleur de servomoteurs PCA9685 doivent suivre strictement le protocole suivant :

  • Fil Orange → Connecté à la broche PWM (signal de commande).
  • Fil Rouge → Connecté à la broche V+ (alimentation).
  • Fil Marron → Connecté à la broche GND (masse).
Connexion du Coupleur de Piles 18650 :

Le coupleur de piles 18650, contenant les deux piles 3.7V, doit être connecté au contrôleur de servomoteurs PCA9685 via le bornier vert.

Programme Arduino pour Radar et Affichage sur LCD

Fonctionnalités du Programme :
  1. Orientation complète du capteur :

    • Le capteur se déplace horizontalement et verticalement grâce aux servomoteurs SG90 (S1 et S2).
    • Les angles de chaque servomoteur varient entre 0° et 180°.
  2. Mesures de distance en temps réel :

    • Les distances mesurées par le capteur HC-SR04 sont affichées sur le shield LCD 1602, en centimètres.
  3. Affichage des positions des servomoteurs :

    • Le shield LCD 1602 affiche continuellement et en temps réel les positions angulaires des servomoteurs S1 et S2.
Le Programme Arduino :

Avant toute chose, vous devez télécharger et installer dans l’IDE Arduino la librairie “Adafruit PWM Servo”

Cette librairie permet à la carte Arduino UNO de communiquer avec la puce PCA9685 installée sur le module ou le Shield I2C 16 servomoteurs:

  1. Téléchargez la librairie au format (.ZIP) sur cette page: “Adafruit PWM Servo”.  > CODE > Télécharger au format ZIP
  2. Dans l’IDE Arduino > Croquis > Importer /Inclure une Bibliothèque > Ajouter la bibliothèque .ZIP
  3. Choisir le dossier de Téléchargements de votre PC, choisissez le fichier “Adafruit-PWM-Servo-Driver-Library-master” > Ouvrir
  4. La librairie s’installe alors automatiquement dans l’IDE Arduino.
				
					/*Programme: Shield LCD 1602 + Keypad Arduino - Pan tilt
 * Auteur: Christian Joseph
 * Date: 22/11/2024
 * Help: contact@atelierdelarobotique.fr
 */

#include <LiquidCrystal.h>
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
#include <SoftwareSerial.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver( 0x40 );
#define SERVOMIN  150 // La longueur d'impulsion 'minimale' (valeur du compteur, max 4096)
#define SERVOMAX  600 // La longueur d'impulsion 'maximale' (valeur du compteur, max 4096) 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);// Configuration des ports de l'écran

// Variables
int lcd_key     = 0;
int adc_key_in  = 0;

// Création des boutons
#define btnRIGHT  0
#define btnUP     1
#define btnDOWN   2
#define btnLEFT   3
#define btnSELECT 4
#define btnNONE   5

//Servomoteurs
uint8_t servo0 = 0;
uint8_t servo1 = 1;
int pulseLen;
int a = 90;
int b = 90;
int vitesse = 50;
String c;
String d;

//Capteur Ultrason
int echo = 2;
int trig = 3;
long lecture_echo;
int duration;
long cm;

void setup()
{
  pwm.begin();
  pwm.setPWMFreq(60);
  pulseLen = map( 90, 0, 180, SERVOMIN, SERVOMAX );
  pwm.setPWM(servo0, 0, pulseLen); //Servomoteur 1 (Gauche - Droite)
  delay(200);
  pwm.setPWM(servo1, 0, pulseLen); //Servomoteur 2 (Haut - Bas)
  delay(200);
  //Configuration des broches du capteur à ultrasons
  pinMode(trig, OUTPUT);
  digitalWrite(trig, LOW);
  pinMode(echo, INPUT);
  Serial.begin(9600);
 lcd.begin(16, 2);              // Initialisation de l'écran
 lcd.setCursor(0,0);            // Curseur au début de la 1ère ligne
 lcd.print("AtelierRobotique"); // Affichage du Message
 delay(2000);
 lcd.setCursor(0,0);            // Curseur au début de la 1ère ligne
 lcd.print("Ser1 Ser2 Mesure"); // Affichage du Message
 lcd.setCursor(0,1);   // Curseur au début de la 2ème ligne
 //Préparation du message
 d= " ";
 c = String(a);
 d += c;
 d += "   ";
 c = String(b);
 d += c;
 d += "  ";
 c = String(cm);
 d += c;
 d += "CM   ";
 lcd.print(d); // Affichage du Message 
 delay(2000);

}
 
void loop()
{
 lcd.setCursor(0,1);            //Curseur au début de la 2eme ligne
 lcd_key = read_LCD_buttons();  // Lecture des touches

 switch (lcd_key)               // Action en cas de touche pressée
 {
   case btnRIGHT: //Déplacement du capteur vers la droite
     {
     if (a > 0){
      a = a - 1;
      pulseLen = map( a, 0, 180, SERVOMIN, SERVOMAX );
      pwm.setPWM(servo0, 0, pulseLen);
      delay(vitesse);
      }
     d= " ";
     c = String(a);
     d += c;
     d += "   ";
     c = String(b);
     d += c;
     d += "  ";
     c = String(cm);
     d += c;
     d += "CM  ";
     lcd.print(d); // Affichage du Message
     break;
     }
   case btnLEFT: //Déplacement du capteur vers la gauche
     {
     if (a < 180){
      a = a + 1;
      pulseLen = map( a, 0, 180, SERVOMIN, SERVOMAX );
      pwm.setPWM(servo0, 0, pulseLen);
      delay(vitesse);
      }
      d= " ";
     c = String(a);
     d += c;
     d += "   ";
     c = String(b);
     d += c;
     d += "  ";
     c = String(cm);
     d += c;
     d += "CM  ";
     lcd.print(d); // Affichage du Message
     break;
     }
   case btnUP: //Déplacement du capteur vers le haut
     {
     if (b > 0){
      b = b - 1;
      pulseLen = map( b, 0, 180, SERVOMIN, SERVOMAX );
      pwm.setPWM(servo1, 0, pulseLen);
      delay(vitesse);
     }
     d= " ";
     c = String(a);
     d += c;
     d += "   ";
     c = String(b);
     d += c;
     d += "  ";
     c = String(cm);
     d += c;
     d += "CM  ";
     lcd.print(d); // Affichage du Message
     break;
     }
   case btnDOWN: //Déplacement du capteur vers le bas
     {
     if (b < 180){
      b = b + 1;
      pulseLen = map( b, 0, 180, SERVOMIN, SERVOMAX );
      pwm.setPWM(servo1, 0, pulseLen);
      delay(vitesse);
     }
     d= " ";
     c = String(a);
     d += c;
     d += "   ";
     c = String(b);
     d += c;
     d += "  ";
     c = String(cm);
     d += c;
     d += "CM  ";
     lcd.print(d); // Affichage du Message
     break;
     }
   case btnSELECT:  //Mesure et affichage de la distance
     {
     //lcd.print("SELECT");
     distance(); //Mesure de distances
     delay(2000);
     d= " ";
     c = String(a);
     d += c;
     d += "   ";
     c = String(b);
     d += c;
     d += "  ";
     c = String(cm);
     d += c;
     d += "CM  ";
     lcd.print(d); // Affichage du Message
     break;
     }
     case btnNONE:
     {
     //On ne fait aucune action ici
     break;
     }
 }
}

// Fonction de lecture des touches
int read_LCD_buttons()
{
 adc_key_in = analogRead(0);   // Lecture du port analogique A0
 if (adc_key_in > 1000) return btnNONE;   
 if (adc_key_in < 50)   return btnRIGHT;     
 if (adc_key_in < 195)  return btnUP;        
 if (adc_key_in < 380)  return btnDOWN;      
 if (adc_key_in < 555)  return btnLEFT;      
 if (adc_key_in < 790)  return btnSELECT;    

 return btnNONE;
}

void distance() { //Mesure de distances
  digitalWrite(trig, HIGH);
  delayMicroseconds(1000);
  digitalWrite(trig, LOW);
  duration = pulseIn(echo, HIGH);
  cm = (duration/2) / 29.1;
  Serial.println (cm);
}
				
			

Présentation Vidéo du Radar Arduino avec Shield LCD 1602 avec Clavier

Conclusion

En réalisant ce projet, nous avons exploré plusieurs concepts essentiels en électronique et en programmation Arduino. De la manipulation des servomoteurs SG90 à l’utilisation du capteur à ultrasons HC-SR04, en passant par l’affichage en temps réel sur le shield LCD 1602, ce tutoriel vous offre une base solide pour développer vos compétences en robotique et domotique.

Ce radar orientable peut être utilisé dans de nombreux domaines, comme la détection d’obstacles, la surveillance ou encore pour des projets éducatifs. N’hésitez pas à personnaliser ce projet en ajoutant de nouvelles fonctionnalités, comme une connexion Bluetooth ou un enregistrement des données sur carte SD.

💡 Aller plus loin : Si vous avez aimé ce projet, consultez nos autres tutoriels pour découvrir encore plus d’idées créatives avec Arduino.

Merci pour votre lecture ! Si vous avez des questions ou des suggestions, n’hésitez pas à nous contacter via nos réseaux sociaux ou par e-mail. Nous sommes impatients de voir vos créations inspirées de ce tutoriel.

Bonjour ! 🌟 Rejoignez notre newsletter pour ne rien manquer.

Recevez nos offres spéciales et les derniers articles directement dans votre boîte de réception

Nous ne faisons pas de spam, promis ! Consultez notre politique de confidentialité pour en savoir plus.

Panier
Retour en haut

Projet sur mesure