[ Arduino 702] Votre premier texte sur le LCD !

Ça y est, on va pouvoir commencer à apprendre des trucs avec notre écran LCD ! Alors, au programme : afficher des variables, des tableaux, déplacer le curseur, etc. Après toutes ces explications, vous serez devenu un pro du LCD, du moins du LCD alphanumérique 😆 . Aller, en route ! Après ça vous ferez un petit TP plutôt intéressant, notamment au niveau de l’utilisation pour l’affichage des mesures sans avoir besoin d’un ordinateur. De plus, pensez au fait que vous pouvez vous aider des afficheurs pour déboguer votre programme !

Ecrire du texte sur le LCD

Afficher du texte

Vous vous rappelez comme je vous disais il y a longtemps « Les développeurs Arduino sont des gens sympas, ils font les choses clairement et logiquement ! » ? Eh bien ce constat ce reproduit (encore) pour la bibliothèque LiquidCrystal ! En effet, une fois que votre écran LCD est bien paramétré, il nous suffira d’utiliser qu’une seule fonction pour afficher du texte ! Allez je vous laisse 10 secondes pour deviner le nom de la fonction que nous allons utiliser. Un indice, ça a un lien avec la voie série… C’est trouvé ? Félicitations à tous ceux qui auraient dit print(). En effet, une fois de plus nous retrouvons une fonction print(), comme pour l’objet Serial, pour envoyer du texte. Ainsi, pour saluer tous les zéros de la terre nous aurons juste à écrire :

et pour code complet avec les déclarations on obtient :

Mais c’est nul ton truc on affiche toujours au même endroit, en haut à gauche !

Oui je sais, mais chaque chose en son temps, on s’occupera du positionnement du texte bientôt, promis !

Afficher une variable

Afficher du texte c’est bien, mais afficher du contenu dynamique c’est mieux ! Nous allons maintenant voir comment afficher une variable sur l’écran. Là encore, rien de difficile. Je ne vais donc pas faire un long discours pour vous dire qu’il n’y a qu’une seule fonction à retenir… le suspens est terrible… OUI évidemment cette fonction c’est print() ! Décidément elle est vraiment tout-terrain (et rédacteur du tutoriel Arduino devient un vrai boulot de feignant, je vais finir par me copier-coller à chaque fois !) Allez zou, un petit code, une petite photo et en avant Guingamp !

Combo ! Afficher du texte ET une variable

Bon vous aurez remarqué que notre code possède une certaine faiblesse… On n’affiche au choix un texte ou un nombre, mais pas les deux en même temps ! Nous allons donc voir maintenant une manière d’y remédier.

La fonction solution

La solution se trouve dans les bases du langage C , grâce à une fonction qui s’appelle sprintf() (aussi appelé « string printf »). Les personnes qui ont fait du C doivent la connaitre, ou connaitre sa cousine « printf ». Cette fonction est un peu particulière car elle ne prend pas un nombre d’argument fini. En effet, si vous voulez afficher 2 variables vous ne lui donnerez pas autant d’arguments que pour en afficher 4 (ce qui parait logique d’une certaine manière). Pour utiliser cette dernière, il va falloir utiliser un tableau de char qui nous servira de buffer. Ce tableau sera celui dans lequel nous allons écrire notre chaine de caractère. Une fois que nous aurons écrit dedans, il nous suffira de l’envoyer sur l’écran en utilisant… print() !

Son fonctionnement

Comme dit rapidement plus tôt, sprintf() n’a pas un nombre d’arguments fini. Cependant, elle en aura au minimum deux qui sont le tableau de la chaine de caractère et une chaine à écrire. Un exemple simple serait d’écrire :

Au début, le tableau message ne contient rien. Après la fonction sprintf(), il possédera le texte « J’ai 42 ans ». Simple non ?

J’utilise un tableau de 16 cases car mon écran fait 16 caractères de large au maximum, et donc inutile de gaspiller de la mémoire en prenant un tableau plus grand que nécessaire.

Nous allons maintenant voir comment changer mon âge en le mettant en dynamique dans la chaîne grâce à une variable. Pour cela, nous allons utiliser des marqueurs de format. Le plus connu est %d pour indiquer un nombre entier (nous verrons les autres ensuite). Dans le contenu à écrire (le deuxième argument), nous placerons ces marqueurs à chaque endroit où l’on voudra mettre une variable. Nous pouvons en placer autant que nous voulons. Ensuite, il nous suffira de mettre dans le même ordre que les marqueurs les différentes variables en argument de sprintf(). Tout va être plus clair avec un exemple !

Cela affichera :

Les marqueurs

Comme je vous le disais, il existe plusieurs marqueurs. Je vais vous présenter ceux qui vous serviront le plus, et différentes astuces pour les utiliser à bon escient :

  • %d qui sera remplacé par un int (signé)
  • %s sera remplacé par une chaîne (un tableau de char)
  • %u pour un entier non signé (similaire à %d)
  • %% pour afficher le symbole ‘%’ 😉

Malheureusement, Arduino ne les supporte pas tous. En effet, le %f des float ne fonctionne pas. 🙁 Il vous faudra donc bricoler si vous désirer l’afficher en entier (je vous laisse deviner comment). Si jamais vous désirez forcer l’affichage d’un marqueur sur un certain nombre de caractères, vous pouvez utiliser un indicateur de taille de ce nombre entre le ‘%’ et la lettre du marqueur. Par exemple, utiliser « %3d » forcera l’affichage du nombre en paramètre (quel qu’il soit) sur trois caractères au minimum. La variable ne sera pas tronqué s’il est plus grande que l’emplacement prévu. Ce paramètre prendra donc toujours autant de place au minimum sur l’écran (utile pour maitriser la disposition des caractères). Exemple :

À l’écran, on aura un texte tel que :

On note l’espace avant le 5 grâce au forçage de l’écriture de la variable sur 2 caractères induit par %2d.

Exercice, faire une horloge

Consigne

Afin de conclure cette partie, je vous propose un petit exercice. Comme le titre l’indique, je vous propose de réaliser une petite horloge. Bien entendu elle ne sera pas fiable du tout car nous n’avons aucun repère réel dans le temps, mais ça reste un bon exercice. L’objectif sera donc d’afficher le message suivant : « Il est hh:mm:ss » avec ‘hh’ pour les heures, ‘mm’ pour les minutes et ‘ss’ pour les secondes. Ça vous ira ? Ouais, enfin je vois pas pourquoi je pose la question puisque de toute manière vous n’avez pas le choix ! 😈 Une dernière chose avant de commencer. Si vous tentez de faire plusieurs affichages successifs, le curseur ne se replacera pas et votre écriture sera vite chaotique. Je vous donne donc rapidement une fonction qui vous permet de revenir à la position en haut à gauche de l’écran : home(). Il vous suffira de faire un lcd.home() pour replacer le curseur en haut à gauche. Nous reparlerons de la position curseur dans le chapitre suivant !

Solution

Je vais directement vous parachuter le code, sans vraiment d’explications car je pense l’avoir suffisamment commenté (et entre nous l’exercice est sympa et pas trop dur). 😉

Secret: Réponse SelectionnerAfficher

Se déplacer sur l’écran

Bon, autant vous prévenir d’avance, ce morceau de chapitre ne sera pas digne du nom de « tutoriel ». Malheureusement, pour se déplacer sur l’écran (que ce soit le curseur ou du texte) il n’y a pas 36 solutions, juste quelques appels relativement simples à des fonctions. Désolé d’avance pour le « pseudo-listing » de fonctions que je vais faire tout en essayant de le garder intéressant…

Gérer l’affichage

Les premières fonctions que nous allons voir concernent l’écran dans son ensemble. Nous allons apprendre à enlever le texte de l’écran mais le garder dans la mémoire pour le ré-afficher ensuite. En d’autres termes, vous allez pouvoir faire un mode « invisible » où le texte est bien stocké en mémoire mais pas affiché sur l’écran. Les deux fonctions permettant ce genre d’action sont les suivantes :

  • noDisplay() : fait disparaître le texte
  • display() : fait apparaître le texte (s’il y en a évidemment)

Si vous tapez le code suivant, vous verrez le texte clignoter toutes les secondes :

Utile si vous voulez attirer l’attention de l’utilisateur ! Une autre fonction utile est celle vous permettant de nettoyer l’écran. Contrairement à la précédente, cette fonction va supprimer le texte de manière permanente. Pour le ré-afficher il faudra le renvoyer à l’afficheur. Cette fonction au nom évident est : clear(). Le code suivant vous permettra ainsi d’afficher un texte puis, au bout de 2 secondes, il disparaitra (pas de loop(), pas nécessaire) :

Cette fonction est très utile lorsque l’on fait des menus sur l’écran, pour pouvoir changer de page. Si on ne fait pas un clear(), il risque d’ailleurs de subsister des caractères de la page précédente. Ce n’est pas très joli.

Attention à ne pas appeler cette fonction plusieurs fois de suite, par exemple en la mettant dans la fonction loop(), vous verrez le texte ne s’affichera que très rapidement puis disparaitra et ainsi de suite.

Gérer le curseur

Se déplacer sur l’écran

Voici maintenant d’autres fonctions que vous attendez certainement, celles permettant de déplacer le curseur sur l’écran. En déplaçant le curseur, vous pourrez écrire à n’importe quel endroit sur l’écran (attention cependant à ce qu’il y ait suffisamment de place pour votre texte). 😛 Nous allons commencer par quelque chose de facile que nous avons vu très rapidement dans le chapitre précédent. Je parle bien sûr de la fonction home() ! Souvenez-vous, cette fonction permet de replacer le curseur au début de l’écran.

Mais au fait, savez-vous comment est organisé le repère de l’écran ?

C’est assez simple, mais il faut être vigilant quand même. Tout d’abord, sachez que les coordonnées s’expriment de la manière suivante \((x,y)\). \(x\) représente les abscisses, donc les pixels horizontaux et \(y\) les ordonnées, les pixels verticaux. L’origine du repère sera logiquement le pixel le plus en haut à gauche (comme la lecture classique d’un livre, on commence en haut à gauche) et à pour coordonnées … (0,0) ! Eh oui, on ne commence pas aux pixels (1,1) mais bien (0,0). Quand on y réfléchit, c’est assez logique. Les caractères sont rangés dans des chaines de caractères, donc des tableaux, qui eux sont adressés à partir de la case 0. Il parait donc au final logique que les développeurs aient gardé une cohérence entre les deux. Puisque nous commençons à 0, un écran de 16×2 caractères pourra donc avoir comme coordonnées de 0 à 15 pour \(x\) et 0 ou 1 pour \(y\). Ceci étant dit, nous pouvons passer à la suite. La prochaine fonction que nous allons voir prend directement en compte ce que je viens de vous dire. Cette fonction nommée setCursor() vous permet de positionner le curseur sur l’écran. On pourra donc faire setCursor(0,0) pour se placer en haut à gauche (équivalent à la fonction « home() ») et en faisant setCursor(15,1) on se placera tout en bas à droite (toujours pour un écran de 16×2 caractères). Un exemple :

Animer le curseur

Tout comme nous pouvons faire disparaître le texte, nous pouvons aussi faire disparaître le curseur (comportement par défaut). La fonction noCursor() va donc l’effacer. La fonction antagoniste cursor() de son côté permettra de l’afficher (vous verrez alors un petit trait en bas du carré (5*8 pixels) où il est placé, comme lorsque vous appuyez sur la touche Insér. de votre clavier). Une dernière chose sympa à faire avec le curseur est de le faire clignoter. En anglais clignoter se dit « blink » et donc tout logiquement la fonction à appeler pour activer le clignotement est blink(). Vous verrez alors le curseur remplir le carré concerné en blanc puis s’effacer (juste le trait) et revenir. S’il y a un caractère en dessous, vous verrez alternativement un carré tout blanc puis le caractère. Pour désactiver le clignotement il suffit de faire appel à la fonction noBlink().

Si vous faites appel à blink() puis à noCursor() le carré blanc continuera de clignoter. En revanche, quand le curseur est dans sa phase « éteinte » vous ne verrez plus le trait du bas.

Jouer avec le texte

Nous allons maintenant nous amuser avec le texte. Ne vous attendez pas non plus à des miracles, il s’agira juste de déplacer le texte automatiquement ou non.

Déplacer le texte à la main

Pour commencer, nous allons déplacer le texte manuellement, vers la droite ou vers la gauche. N’essayez pas de produire l’expérience avec votre main, ce n’est pas un écran tactile, hein ! 😉 Le comportement est simple à comprendre. Après avoir écrit du texte sur l’écran, on peut faire appel aux fonctions scrollDisplayRight() et scrollDisplayLeft() vous pourrez déplacer le texte d’un carré vers la droite ou vers la gauche. S’il y a du texte sur chacune des lignes avant de faire appel aux fonctions, c’est le texte de chaque ligne qui sera déplacé par la fonction. Utilisez deux petits boutons poussoirs pour utiliser le code suivant. Vous pourrez déplacer le texte en appuyant sur chacun des poussoirs !

Déplacer le texte automatiquement

De temps en temps, il peut être utile d’écrire toujours sur le même pixel et de faire en sorte que le texte se décale tout seul (pour faire des effets zolis par exemple). :mrgreen: Un couple de fonctions va nous aider dans cette tâche. La première sert à définir la direction du défilement. Elle s’appelle leftToRight() pour aller de la gauche vers la droite et rightToLeft() pour l’autre sens. Ensuite, il suffit d’activer (ou pas si vous voulez arrêter l’effet) avec la fonction autoScroll() (et noAutoScroll() pour l’arrêter). Pour mieux voir cet effet, je vous propose d’essayer le code qui suit. Vous verrez ainsi les chiffres de 0 à 9 apparaitre et se « pousser » les uns après les autres :

Créer un caractère

Dernière partie avant la pratique, on s’accroche vous serez bientôt incollable sur les écrans LCD ! En plus réjouissez-vous je vous ai gardé un petit truc sympa pour la fin. En effet, dans ce dernier morceau toute votre âme créatrice va pouvoir s’exprimer ! Nous allons créer des caractères !

Principe de la création

Créer un caractère n’est pas très difficile, il suffit d’avoir un peu d’imagination. Sur l’écran les pixels sont en réalités divisés en grille de 5×8 (5 en largeur et 8 en hauteur). C’est parce que le contrôleur de l’écran connait l’alphabet qu’il peut dessiner sur ces petites grilles les caractères et les chiffres. Comme je viens de le dire, les caractères sont une grille de 5×8. Cette grille sera symbolisée en mémoire par un tableau de huit octets (type byte). Les 5 bits de poids faible de chaque octet représenteront une ligne du nouveau caractère. Pour faire simple, prenons un exemple. Nous allons dessiner un smiley, avec ses deux yeux et sa bouche pour avoir le rendu suivant :

0 0 0 0 0
X 0 0 0 X
0 0 0 0 0
0 0 0 0 0
X 0 0 0 X
0 X X X 0
0 0 0 0 0
0 0 0 0 0

Ce dessin se traduira en mémoire par un tableau d’octet que l’on pourra coder de la manière suivante :

La lettre ‘B’ avant l’écriture des octets veut dire « Je t’écris la valeur en binaire« . Cela nous permet d’avoir un rendu plus facile et rapide.

Oh le joli smiley !

L’envoyer à l’écran et l’utiliser

Une fois que votre caractère est créé, il faut l’envoyer à l’écran, pour que ce dernier puisse le connaitre, avant toute communication avec l’écran (oui oui avant le begin()). La fonction pour apprendre notre caractère à l’écran se nomme createChar() signifiant « créer caractère ». Cette fonction prend deux paramètres : « l’adresse » du caractère dans la mémoire de l’écran (de 0 à 7) et le tableau de byte représentant le caractère. Ensuite, l’étape de départ de communication avec l’écran peut-être faite (le begin). Ensuite, si vous voulez écrire ce nouveau caractère sur votre bel écran, nous allons utiliser une nouvelle (la dernière fonction) qui s’appelle write(). En paramètre sera passé un int représentant le numéro (adresse) du caractère que l’on veut afficher. Cependant, il y a là une faille dans le code Arduino. En effet, la fonction write() existe aussi dans une librairie standard d’Arduino et prend un pointeur sur un char. Le seul moyen de les différencier pour le compilateur sera donc de regarder le paramètre de la fonction pour savoir ce que vous voulez faire. Dans notre cas, il faut passer un int. On va donc forcer (on dit « caster ») le paramètre dans le type « uint8_t » en écrivant la fonction de la manière suivante : write(uint8_t param). Le code complet sera ainsi le suivant :

Désormais, vous savez l’essentiel sur les LCD alphanumériques, vous êtes donc aptes pour passer au TP. 😉

57 commentaires

  1. Bonjour,
    la fonction sprintf() n’écris rien sur mon afficheur…
    pourtant l’affichage fonctionnait très bien à la section 701 avec lcd.print(«  »).
    Je me demandais si vous aviez une idée pour régler mon problème?

    merci de prendre le temps de me répondre,
    cordialement,
    Maxime

    • La fonction sprintf se contente d’écrire la chaîne en paramètre 2 dans la chaîne variable en paramètre 1. Dans ton exemple, elle copie « J’ai 42 ans » dans message. C’est assez pratique des qu’il faut rajouter des variables comme « J’ai %d ans ».
      Il faut ensuite envoyer cette chaîne a l’écran via lcd.print comme tu l’as déjà fait 🙂

      (PS: je me suis permis de mettre en forme sans le modifier le code que tu as posté)

  2. Bonjour,

    Tout d’abord merci pour cette suite de tutoriel claire tout en étant assez complet 😉

    Pour ma part j’ai un soucis avec les caractère spéciaux.
    Lorsqu’il s’affiche, j’ai droit à un petit tas de pixel.

    Le plus intriguant est que j’ai beau modifier le code de l’image (que ce soir un smiley ou un rectangle noir) le résultat est toujours le même.

    j’utilise la librairie LiquidCrystal_I2C.h car mon écran est en I2C.

    #include
    #include

    #define I2C_ADDR 0x27

    #define BACKLIGHT_PIN 3
    #define En_pin 2
    #define Rw_pin 1
    #define Rs_pin 0
    #define D4_pin 4
    #define D5_pin 5
    #define D6_pin 6
    #define D7_pin 7

    #define LED_OFF 1
    #define LED_ON 0

    LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);

    byte smiley[8] = { //créer le caractère. Placer avant le begin
    B00000,
    B10001,
    B00000,
    B00000,
    B10001,
    B01110,
    B00000,
    };

    void setup()
    {
    init();
    lcd.createChar(0, smiley); //apprend le caractère à l'écran LCD //placer avec begin
    lcd.begin(16, 2);
    }

    void loop()
    {
    // Reset the display
    lcd.clear();

    lcd.write((uint8_t) 0); //affiche le caractère spécial de l'adresse 0
    delay(1000);
    }

    Une idée ?

    • La comme ça pas trop d’idée, je n’ai pas eu l’occasion de jouer avec des écrans en I2C donc je ne sais pas si la librairie est fiable ou non.
      Pour discuter de tout ça et debugguer l’ensemble, je te propose d’ouvrir un sujet sur un forum dédié (je suis souvent dans la section « Systèmes et Matériel » du site Zeste De Savoir par exemple). Ce sera plus pratique pour échanger/debugguer que cette zone de commentaire 🙂

    • Bonjour, quand tu essai d’afficher un texte de type println (hello world )ca fonctionne ?

      A première vu tu définis des pins associer au lcd alors que en i2c tu utilise seulement deux broches qui doivent être impérativement A4=> sda et A5 sur =>scl.

      je pense que pour commencé tu peux supprimer cette partie:

      #define I2C_ADDR 0x27

      #define BACKLIGHT_PIN 3
      #define En_pin 2
      #define Rw_pin 1
      #define Rs_pin 0
      #define D4_pin 4
      #define D5_pin 5
      #define D6_pin 6
      #define D7_pin 7

      puis pour paramétrer le lcd

      modifier cette ligne :

      LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);

      par

      LiquidCrystal_I2C lcd(0x27,16,2); //adresse le lcd a 0x27 pour 16 charactéres et deux lignes

      Après dans void setup() {

      lcd.init(); //initialise le lcd
      lcd.begin(16, 2);// Défini le nb de colonnes puis lignes
      lcd.backlight(); //allume le rétroéclairage

      […] }

  3. Bonjour,

    Tout d’abord super boulot que tous ces tutos voir même cours !!

    J’ai un problème concernant l’exercice pour afficher l’heure. En effet, mes secondes n’arrivent jamais jusqu’à 60 puisqu’au bout de 30s l’affichage semble bloquer durant 1-2s puis l’affichage disparait un court instant et tout redémarre à zéro donc pas très pratique pour faire une horloge…

    Il me semblait avoir déjà vu un phénomène de ce type sur les précédents montage (comme un retour à zéro du programme) mais je pensais que le problème venait de mon montage…apparemment non

    une idée d’où pourrait provenir le problème ? merci d’avance

  4. Petit détail supplémentaire : pendant l’exécution du programme, la led L (clle du haut du groupe de 3 au dessus de tx et rx) et la led on sont allumées. Au moment où l’horloge se réinitialise/repart à zéro, la led on reste allumée et la led L se met a clignoter avant de s’éteindre puis tout revient à l’état précédent

  5. Bonsoir, petite question
    J’ai récupéré un pc portable mort dont l’écran LCD 15″ fonctionne encore (en principe)
    J’aimerai savoir s’il existe un moyen de le connecter à un MC type arduino?

  6. Bonsoir,
    Pour moi, l’écran s’éteint quand le programme est téléversé ! 2 secondes + tard, il se rallume pendant 1/2 seconde et reste noir.
    Je viens de recevoir cet écran LCD2004A avec interface I2C que j’ai branché sur un Arduino Mega2560.
    Branchement SDA sur pin 20 et SCL sur pin 21.

    Le programme basic :
    —————————
    #include « Wire.h »
    #include « LiquidCrystal_I2C.h »

    LiquidCrystal_I2C lcd(0x27,20,4); // Adresse : 0x27 pour 20 colonnes et 4 lignes

    void setup()
    {
    lcd.init(); // initialisation du lcd
    lcd.backlight(); // rétro éclairage actif
    lcd.begin(20,4); // 20 cols et 4 rows
    lcd.print(« Test »); // écrire « Test »
    }

    void loop()
    {

    }

    J’ai quand même essayé sans I2c avec 4 et 8 bits de données avec la librairie LiquidCrystal.

    L’écran est-il HS ou j’ai manqué quelquechose ?

    • Il faudrait commencer par vérifier que les branchements sont bien fait (si c’est sur breadboard alors vérifier deux fois, ces dernières entraînent souvent des faux contacts). Ensuite… je ne sais pas. Le code semble ok donc difficile de dire d’ou le problème pourrait venir.

      • Merci pour ta réponse. Pas de breadboard (en attente de livraison), branchement direct avec différents fils dont l’utilisation pour un ESP8266 ou un HC-05 ne pose pas de problèmes. L’écran s’allume bien quand je branche la carte en usb, le potentiometre rempli bien sa fonction.
        Bon, je verrais bien dans quelques jours puisque j’ai commandé 2 lcd différents, un arduino uno et due…

        • C’est bon, ça marche !
          pb de bibliothèque avec cette chinoiserie d’écran…
          La bonne bibliotheque est « LiquidCrystal_I2C2004V1_Chinese » au lieu de la derniere « LiquidCrystal_I2C ».
          Au boulot maintenant…. 😉

          • Bonjour Camille,
            Merci pour le lien vers cette bibliotheque, c’est la premiere fois en trois jours ou cet écran m’affiche enfin quelque chose. Par contre il ne m’affiche à chaque fois que la premiere letter et ensuite rien…..
            Est ce pareil chez toi? (perso j’ai une arduino due)

            Gilles

  7. Pingback: Bibliographie | tpeaffichgechargedrone

  8. Bonjour Eskimon,
    J’ai le même écran que vous, pourriez vous m’expliquer comment gérer les boutons a l’aide de la prise analogique, j’en ai besoin pour un projet tuteuré, et je n’ai pas le DataShield de l’écran..

    Je ne sais donc pas comment m’en servir, enfin l’affichage, j’ai changer les branchement et je le gère nickel, mais pour ce qui est des boutons j’ai un peu de mal de l’accorde :).

    Je voudrais donc savoir si tu pouvais m’aider face a ce problème :).

    • Les boutons doivent etre lu via une lecture analogique sur une des entrées analogiques de l’Arduino. Chaque bouton provoque une tension différente sur cette broche. Il suffit alors de déterminer la tension induite par chaque bouton pour avoir une idee de comment lire chacun d’entres eux 🙂

  9. Bonjour pour ma part j’ai un petit soucis très difficilement explicable, c’est d’ailleurs la raison pour laquelle je ne trouve rien sur mon problème.

    Alors je copie/colle le code de tout en haut le truc « nul qui affiche toujours la même chose » et sa me donne à peu près sa…

    « :;*:$^$^ùùù’ç » … Alors bien sur sa ne me donne pas exactement sa, mais vous aurez compris que sa ne donne pas du tout ce que je veux. ^^ Si quelqu’un aurez une idée du pourquoi du comment, je suis prenneur

  10. salut je veux que l’afficheur m’affiche la vitesse d’un moteur ,mais notons bien que la vitesse est variable
    ça veut dire on écrit lcd.print(« la vitesse du moteur est ») ,mais je veux qu’elle m’affiche instantanée du vitesse
    mrc d’avance 🙂

  11. Bonjour,
    Votre site est super et j’ai lu vos articles durant mais 15 jours de vacances 🙂
    Je souhaiterais acheter un afficheur LCD afin de mettre tout cela en pratique. Celui que je compte prendre ressemble très fortement à celui de votre vidéo. Est-il enfichable sur une Arduino Uno?
    Il indique également  » Pins 4, 5, 6, 7, 8, 9 and 10 are used to interface with the LCD » Comment peut-on les identifier pour les déclarer dans LiquidCrystal lcd();
    D’avance un grand merci pour votre réponse!

    • Dans l’idéal ce devrait être écrit dans la description sur le site du fournisseur. Sinon il faudra fouiller dans les commentaires si jamais qqun a eu le même souci. Et sinon il faudra chercher la correspondance des broches soit même 🙁

  12. Pingback: ARDUINO - christophelucas | Pearltrees

  13. Bonjour,

    Super tuto, bonnes explications, je dis clap clap !

    Une petite question (je débute en arduino) : je suis un peu perdu entre les fonctions des bibliothèques Arduino et les fonctions du langage C.

    Par exemple la fonction sprintf est-elle utilisable sur Arduino « telle que » ? J’entends par là est-ce que cela fonctionnera sur ma config. Je ne vois pas comment cette fonction connaîtrait les pins de contrôle et celles de données ? est-ce que ton exemple de fonction sprintf est un résultat uniquement utilisable sur pc (sortie standard = écran) ??

    Merci et bonne continuation !

    Pierre

  14. Salut,

    Je suis entrain de faire un projet sur une balance que je veux mettre sur des cylindres.Jai prsi un programme et fait mes branchements,j’ai mis l’ecran LCD,le Load cell amp et mon weight sensor,mais le truc, c’est que sur mon ercan LCD s’affiche des valeurs sachant que j’ai pas mis de poids.

    Peux tu m’expliquer l’anomalie?

    bertrand.

    • Salut,

      Peut tt détailler un peu plus ton problème s’il te plaît. Par exemple une image de ton câblage ou encore comment traite tu les informations qui arrivent sur ton µP?

      J’ai déja eu ce problème il y a peu de temps je ne sais pas si cela peut aider mais j’ai du mettre une résistance (de 10K pour ma part) en parallèle entre mon entrée de donnée et ma masse car sans ça j’avais des perturbations qui provoquaient des fausses données. En gros mon entrée donne un 1 logique alors qu’elle est a 0 avec mon capteur pour une raison obscure (qui a été corrigé grace a ma résistance de 10K mais es-ce peut être une bétise que j’ai réalisé? en tout cas ça marche).

      En espérant t’avoir aidé

      Gr33n

      • Salut,
        J’ai fait de l’électronique il y a 25 ans au moins et j’avoue que tout ceci me donne envie de remettre les mains dans le cambouis. j ‘ai déjà commandé mon arduino uno mais je me pose une petite question et je vais vous faire partager ma réflexion.
        Voila, vous dites que le contraste se règle avec une tension sur 1 broche, seulement moi, l’utilisation d’un potar me gène un peut alors je me demande donc (puisque notre arduino possède des sorties analogiques) si on peut régler ce contraste avec une sortie analogique quitte à passer par un transistor si cette opération est trop gourmande en courant ?

        En tout cas je voulais vous dire un grand merci pour le travail que vous effectué. En effet c’est grâce à des gens comme vous qui parviennent à « simplifier ou vulgariser » le fonctionnement de matériel qui n’est pas simple à la base que le monde du DIY (Do It Yourself) s’élargie de plus en plus. Eh oui monsieur, vous contribuez à casser le monopole des multinationales qui envahissent les marchés avec des objets technologique à des prix parfois vraiment irréels.

        Grand Merci.
        WarriorProg

  15. mon arduino ne comprend pa le LiquidCristal lcd

    horloge_lcd_1:4: error: ‘LiquidCristal’ does not name a type
    horloge_lcd_1:6: error: expected primary-expression before ‘;’ token
    ‘LiquidCristal’ does not name a type

    horloge_lcd_1.ino:2:27: fatal error: LiquidCristal.h: No such file or directory
    compilation terminated.
    Erreur lors de la compilation.

  16. Salut,
    Moi j’ai un projet à faire:
    Je m’explique:

    Je dois réaliser une pompe de distribution d’aliments pour les porcs. La pompe est manuelle.
    Ce que je dois faire pour l’éleveur c’est de leur permettre de mettre la quantité d’aliments sans débordement en affichant sur un écran ce qu’il met pour qu’il sache à quel moment il doit s’arrêter.

    A l’aide de la carte arduino relié à un écran LCD, permettre à l’éleveur en appuyant sur le bouton de voir la quantité d’aliment  » ex: 500 grammes » et d’arrêter quand il atteint la quantité souhaitée.

    Merci d’avance

  17. Bonjour,

    Tous d’abord un grand merci pour votre travail! étant débutant complet, grâce à vos cours j’ai pu commencé à faire quelques montages (très simple, je part de zéro), mais j’espère pouvoir vite progresser.

    En mixant plusieurs de vos TP/cours, j’ai fait affiché les valeurs d’une sonde de T°C sur un LCD. Pour aller un peu plus loin, j’ai pu mettre un interrupteur pour déclencher le rétroéclairage du LCD ça c’est ok, mais ou je bloque c’est avec la fonction lcd.noDisplay. Je voudrais pouvoir arrêter d’afficher le texte sur le LCD avec une condition if qui soit: Si l’interrupteur est « off » (donc le rétroéclairée coupé) alors le lcd n’affiche pas. Sinon, il s’affiche.

    Après avoir passé plusieurs heures dessus, je n’arrive à rien de bien…

    Pourriez-vous le dire si noDIsplay peut être utilisé et couplé avec une fonction if?

    Pour info, voici la condition qui me pose soucis:

    void loop() {

    if(etatbouton==HIGH)
    {
    lcd.display();
    }

    else
    {
    lcd.noDisplay();
    }
    }

    Merci par avance si vous pouvez m’aiguiller sur la voie à suivre!

    Bonne continuation.

    David

  18. Salut Eskimon , voila j’ai un petit soucis.

    J’ai deux arduino qui communique ensemble via RX TX.

    Sur le maitre j’ai un programme qui me permet de faire tourner 2 moteur pas a pas a 700 tours/minutes. Et de programmer le nombre de tour que je souhaite, et le sens de rotation des moteurs, et sa via une liaison BT.
    A cause de sa je ne peut pas gérer l’affichage qui décompterai le nombre de tour (a chaque print sur la fonction série sa coupe la rotation des moteurs). Du coup je voulais gérer l’affichage avec un autre arduino.

    Donc sur l’esclave j’envoie le nombre de tour que j’ai programmer sur le maitre, et je voulais l’afficher sur un LCD, mais au lieu de m’afficher seulement le bon chiffre il me colle un truc bizarre … pour disons 21 programmer il m’écris 1021et deux caractère chinois et je comprend pas pourquoi aurais tu une solution ?

  19. Bonjour, je suis nouveau avec Arduino et je ne comprends pas un truc. Je voudrais pouvoir autoriser l’utilsateur à rentrer son nom. Don là j’en suis eulement à l’affichage mais je n;arrive pas à ce que la variable « nom » rajoute la lettre au fur et à mesure des enter. J’utilise un potentiometre pour changer les lettres à choisir, elle se remplace bien à chaque fois (quand je change le code) mais je voudrai qu’elle s’ajoute à la varibale « nom ». Donc que ce soit nom = rien, nom = a (affich a) -> nom = a+d (affich ad) -> nom = ad+r…

    Mais ça ne fonctionne pas….

    Pourriez-vous m’aider ?

    #include

    LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

    int const potPin = A0;
    int potVal;
    int alphaNum;
    char alpha[] = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’};
    char lettre;
    char nom[8]= » « ;
    int switchState=0;

    void setup() {

    Serial.begin(9600);
    pinMode(8,INPUT);

    lcd.begin(16, 2);
    lcd.print(« **** MaCorp **** »);
    delay(1200);
    lcd.setCursor(0,1);
    lcd.print( » Welcome ! »);
    delay(2000);
    lcd.clear();
    lcd.print(« What’s ur name? »);

    }

    void loop(){

    switchState = digitalRead(8);

    potVal = analogRead(potPin);
    alphaNum = map(potVal, 0, 1023, 0, 25);
    lcd.setCursor(0,1);

    lcd.print(alpha[alphaNum]);
    lcd.print( » « );
    lcd.print(nom);
    lcd.blink();

    if (switchState == HIGH) {

    nom = nom.lettre;
    }

    delay(500);
    }

Laisser un commentaire