Les méthodes d'affichage avec les cartes Arduino

La carte Arduino ne dispose pas nativement d'un afficheur. Dans le cadre de l'utilisation d'un microcontrôleur en physique-chimie, il est indispensable de pouvoir afficher le résultat d'une mesure.

Cette partie aborde deux méthodes distinctes :

  • l'utilisation du moniteur série.

  • l'utilisation d'un afficheur LCD additionnel.

Le moniteur série

Méthode

La platine Arduino ne possède pas d'écran. Même s'il est possible d'en connecter un, on peut se contenter dans certains cas du moniteur série.

Si l'Arduino est connecté à l'ordinateur par son câble USB, il peut envoyer des données sur le moniteur série, qui est une fenêtre d'affichage accessible en cliquant sur dans la fenêtre du logiciel de programmation de l'Arduino.

Pour utiliser le moniteur série en tant qu'afficheur, les trois instructions de la bibliothèque dédiée sont  :

  • Serial.begin(9600); pour initialiser la communication avec le moniteur série, de place dans la boucle void Setup() du programme.

  • Serial.print(variable ou texte entre " "); pour afficher la valeur d'une variable ou du texte.

  • Serial.println(variable ou texte entre " "); comme précédemment mais avec un retour à la ligne.

  • Serial.write(CodeCaractère); pour afficher un caractère spécial à partir de son code.

ExempleRetour sur le clignotement de la DEL

On se propose de reprendre le programme permettant de faire clignoter la DEL et d'ajouter les lignes de programme pour afficher son état (« Allumee » ou « Eteinte ») dans le moniteur série. Pour des raisons d'encodage, on n'affiche pas de caractères accentués.

Le code modifié ci-dessous permet l'affichage sur le moniteur série.

1
int pinLed = 3;//Numéro de la sortie numérique alimentant la DEL
2
void setup() {
3
  // put your setup code here, to run once:
4
  pinMode(pinLed, OUTPUT);//L'E/S est utilisée en SORTIE
5
  Serial.begin(9600);//Initialisation de la communication
6
  //avec le moniteur série
7
}
8
void loop() {
9
  // put your main code here, to run repeatedly:
10
  analogWrite(pinLed, 50); //On allume la DEL
11
  Serial.println("Allumee");//Affichage de l'état de la DEL
12
  delay(2000);//On attend 2 secondes
13
  digitalWrite(pinLed, 0); //On éteint la DEL
14
  Serial.println("Eteinte");//Affichage de l'état de la DEL
15
  delay(2000);//On attend 2 secondes
16
}

Pour tester l'affichage de la valeur d'une variable :

Modifiez le code précédent pour obtenir l'affichage ci-contre sur le moniteur série en provoquant l'affichage de la valeur de la variable pinLed et non directement du caractère « 3 ».

Affichage sur le moniteur sérieInformations[1]

Utiliser un afficheur LCD

Les afficheurs LCD additionnels

Les afficheurs LCD les moins onéreux sont les écrans 2 lignes - 16 colonnes ou 4 lignes - 20 colonnes comme ci-contre.

Sans module additionnel, leur câblage est fastidieux et ne peut être réalisé dans de bonnes conditions et dans un temps court par les élèves qui découvrent ce type de matériel (voir schéma ci-dessous).

Écran LCD 2 lignes - 16 colonnes
Câblage d'un écran LCD sans module I2CInformations[2]

ConseilAfficheur LCD avec module I2C (À PRIVILÉGIER)

Il est possible de ne pas avoir à connecter 12 broches de l'écran LCD en lui adjoignant un module I2C. On trouve l'ensemble déjà soudé comme sur les photographies ci-contre.

Écran LCD avec module I2C - Recto versoInformations[3]

Seules quatre broches sont alors nécessaires :

  • Vcc pour le +5V

  • GND à la masse

  • SCL sur l'entrée analogique A5 de la carte Arduino ou sur la borne marquée SCL

  • SDA sur l'entrée analogique A4 de la carte Arduino ou sur la borne marquée SDA

L'utilisation d'un composant avec module I2C interdit l'utilisation des entrées analogiques A4 et A5.

Le potentiomètre du module I2C (en bleu sur la photographie) permet d'ajuster le contraste de l'écran.

L'utilisation de ce type de module LCD nécessite une bibliothèque dédiée. Vous pouvez la récupérer en cliquant sur ce lien : LiquidCrystal_I2C.zip [zip]. Sa compatibilité a été testée avec les cartes Arduino Uno Rev 3 et l'IDE en version 1.8.9. Il s'agit d'une version modifiée de ce qui est téléchargeable sur le site DFRobot afin de corriger un bug d'affichage (seule la première lettre d'un mot s'affiche).

Connexion d'un écran LCD avec module I2C à une carte Arduino UnoInformations[4]

Pour ajouter la bibliothèque à l'environnement de programmation

Lancer Arduino IDE, puis cliquer sur Croquis -> Inclure une bibliothèque -> Ajouter la bibliothèque .ZIP.

Pour inclure les bibliothèques dans le programme

Deux bibliothèques sont nécessaires pour faire fonctionner ce type d'affichage. On les inclut par les deux lignes suivantes dans la zone de déclaration des variables (en début de code) :

1
#include <Wire.h>
2
#include <LiquidCrystal_I2C.h>

Dans cette même zone du code (avant setup() et loop()), on déclare l'écran LCD avec son adresse de communication, son nombre de colonnes et de lignes :

1
LiquidCrystal_I2C lcd(0x20, 16, 2); //Pour une adresse de communication 0x20 et un écran 16 colonnes, 2 ligne

FondamentalLe commandes essentielles

Pour gérer l'affichage des grandeurs mesurées, seules quelques commandes sont nécessaires, le préfixe lcd est lié à ce qui est déclaré dans la ligne de commande précédente :

  • lcd.init(); pour initialiser l'écran LCD, à placer dans la boucle setup().

  • lcd.backlight(); pour allumer le rétroéclairage, à placer dans la boucle setup().

  • lcd.clear(); pour effacer l'écran LCD.

  • lcd.setCursor(colonne,ligne); pour positionner le curseur.

  • lcd.print(variable ou "chaîne de caractère"); pour afficher une valeur ou une chaîne de caractère.

  • lcd.write(code_caractère); pour afficher un caractère particulier dont on connaît le code. Exemple lcd.write(223) affiche le symbole °.

Remarque : il n'existe pas l'équivalent du println du moniteur série. Pour changer de ligne il faut utiliser la commande lcd.setCursor(colonne,ligne).

MéthodeAfficher l'état de la DEL sur l'écran LCD

On reprend le même objectif qu'avec le moniteur série mais en affichant l'état de la DEL sur un écran LCD avec module I2C.

Câblez l'écran LCD comme indiqué précédemment puis testez le programme

1
#include <LiquidCrystal_I2C.h>//Ajout de la bibliothèque LCD
2
int pinLed = 3;//Numéro de la sortie numérique alimentant la DEL
3
LiquidCrystal_I2C lcd(0x20,16,2);//Déclaration de l'écran LCD
4
void setup() {
5
  // put your setup code here, to run once:
6
  pinMode(pinLed, OUTPUT);//L'E/S est utilisée en SORTIE
7
  lcd.init();//On initialise l'écran
8
  lcd.backlight();//Allumage du rétroéclairage
9
}
10
void loop() {
11
  // put your main code here, to run repeatedly:
12
  lcd.clear();//On efface l'écran
13
  analogWrite(pinLed, 50); //On allume la DEL
14
  lcd.print("Allumé");//Affichage de l'état de la DEL
15
  delay(2000);//On attend 2 secondes
16
  lcd.clear();
17
  digitalWrite(pinLed, 0); //On éteint la DEL
18
  lcd.print("Eteinte");//Affichage de l'état de la DEL
19
  delay(2000);//On attend 2 secondes
20
}

ComplémentConnaître l'adresse de communication du port I2C de l'écran

Pour vérifier l'adresse de communication du bus I2C utilisé par l'écran, on peut utiliser le programme suivant avec l'écran connecté à la carte Arduino.

Le moniteur série affiche les adresses des interfaces I2C détectées.

1
    // --------------------------------------
2
    // i2c_scanner
3
    //
4
    // Version 1
5
    //    This program (or code that looks like it)
6
    //    can be found in many places.
7
    //    For example on the Arduino.cc forum.
8
    //    The original author is not know.
9
    // Version 2, Juni 2012, Using Arduino 1.0.1
10
    //     Adapted to be as simple as possible by Arduino.cc user Krodal
11
    // Version 3, Feb 26  2013
12
    //    V3 by louarnold
13
    // Version 4, March 3, 2013, Using Arduino 1.0.3
14
    //    by Arduino.cc user Krodal.
15
    //    Changes by louarnold removed.
16
    //    Scanning addresses changed from 0...127 to 1...119,
17
    //    according to the i2c scanner by Nick Gammon
18
    //    http://www.gammon.com.au/forum/?id=10896
19
    // Version 5, March 28, 2013
20
    //    As version 4, but address scans now to 127.
21
    //    A sensor seems to use address 120.
22
    // Version 6, November 27, 2015.
23
    //    Added waiting for the Leonardo serial communication.
24
    //
25
    //
26
    // This sketch tests the standard 7-bit addresses
27
    // Devices with higher bit address might not be seen properly.
28
    //
29
30
    #include <Wire.h>
31
32
33
    void setup()
34
    {
35
      Wire.begin();
36
37
      Serial.begin(9600);
38
      while (!Serial);             // Leonardo: wait for serial monitor
39
      Serial.println("\nI2C Scanner");
40
    }
41
42
43
    void loop()
44
    {
45
      byte error, address;
46
      int nDevices;
47
48
      Serial.println("Scanning...");
49
50
      nDevices = 0;
51
      for(address = 1; address < 127; address++ )
52
      {
53
        // The i2c_scanner uses the return value of
54
        // the Write.endTransmisstion to see if
55
        // a device did acknowledge to the address.
56
        Wire.beginTransmission(address);
57
        error = Wire.endTransmission();
58
59
        if (error == 0)
60
        {
61
          Serial.print("I2C device found at address 0x");
62
          if (address<16)
63
            Serial.print("0");
64
          Serial.print(address,HEX);
65
          Serial.println("  !");
66
67
          nDevices++;
68
        }
69
        else if (error==4)
70
        {
71
          Serial.print("Unknown error at address 0x");
72
          if (address<16)
73
            Serial.print("0");
74
          Serial.println(address,HEX);
75
        }
76
      }
77
      if (nDevices == 0)
78
        Serial.println("No I2C devices found\n");
79
      else
80
        Serial.println("done\n");
81
82
      delay(5000);           // wait 5 seconds for next scan
83
    }