View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Contrôler un afficheur LCD alpha-numérique à partir du Terminal Série

Par X. HINAULT - Page créée le : 8/2/2011.

1.  Présentation

Ce programme permet de contrôler un afficheur LCD alpha-numérique depuis le Terminal série du logiciel Arduino à l'aide d'instructions simple (blink, noblink, clear, etc..).

Ce programme exploite les possibilités très intéressantes de l'objet String qui permet de manipuler facilement les chaînes de caractères.

Ce programme est particulièrement pratique pour ceux qui débute avec l'utilisation d'un afficheur LCD : ils pourront utiliser le programme directement dans Arduino pour se familiariser avec les instructions de la librairie LCD.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC
  • Utilise un afficheur LCD alphanumérique en mode 4 bits

Ressources utiles associées à ce programme :

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • une plaque d'essai pour montage sans soudures,
  • des straps,

3.  Instructions de montage

  • La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
  • Connexion du LCD sur les broches de la carte Arduino :
    • Connecter broche RS du LCD sur la broche 2
    • Connecter broche E du LCD sur la broche 3
    • Connecter broche D4 du LCD sur la broche 4
    • Connecter broche D5 du LCD sur la broche 5
    • Connecter broche D6 du LCD sur la broche 6
    • Connecter broche D7 du LCD sur la broche 7

4.  Le schéma théorique du montage

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

6.  Fonctionnement du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Explication du programme

7.1  Au niveau de la partie déclarative :

7.2  Au niveau de la fonction d'initialisation setup( ) :

7.3  Au niveau de la boucle principale, la fonction loop ( ) :

8.  Mise en oeuvre du programme

8.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

8.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
  • La fenêtre « Terminal » s'ouvre alors :
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

Point important, il faut également activer l'option "newline" qui active l'envoi du caractère '\n' (ascii 10) lorsque l'on saisi quelque chose dans le champ du Terminal suivi d'un <send>

8.3  Fonctionnement

9.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 8/2/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Ce programme permet de contrôler un afficheur LCD alpha-numérique
 depuis le Terminal série du logiciel Arduino
 à l'aide d'instructions simple (blink, noblink, clear, etc..).
 Utilise l'objet String pour analyser la chaine recue via le port Série
 */


// --- Fonctionnalités utilisées ---

// Utilise la connexion série vers le PC
// Utilise un afficheur LCD alphanumérique en mode 4 bits

// -------- Circuit à réaliser ---------

// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)

// Connexion du LCD sur les broches de la carte Arduino :
// Connecter broche RS du LCD sur la broche 2
// Connecter broche E du LCD sur la broche 3
// Connecter broche D4 du LCD sur la broche 4
// Connecter broche D5 du LCD sur la broche 5
// Connecter broche D6 du LCD sur la broche 6
// Connecter broche D7 du LCD sur la broche 7


// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD

// --- Déclaration des constantes utiles ---

// --- Déclaration des constantes des broches E/S numériques ---

const int RS=2; // Constante pour la broche 2
const int E=3; // Constante pour la broche 3
const int D4=4; // Constante pour la broche 4
const int D5=5; // Constante pour la broche 5
const int D6=6; // Constante pour la broche 6
const int D7=7; // Constante pour la broche 7

// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---

 int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
 long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
 long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
 String chaineReception=""; // déclare un objet String vide pour reception chaine
 String chaineTest=""; // déclare un objet String pour analyse chaine réception
 int valeur1=0, valeur2=0; // variables int pour analyse chaine réception
 int ligne, colonne; // variables de positionnement sur le LCD avec 1er caractère à ligne=0 et colonne=0

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

//------------ Création d'un objet afficheur LCD alphanumérique ----
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en mode 4 bits


// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

// Initialisation de l'afficheur LCD
lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes
delay(10); // pause rapide pour laisser temps initialisation

// Test de l'afficheur LCD
lcd.clear(); // efface LCD
lcd.print("LCD OK"); // affiche texte
delay (1000); //pause
lcd.clear(); // efface LCD


// ------- Broches en sorties numériques -------  

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  


// ------- Initialisation des variables utilisées -------  

//----------- Affichage des instructions dispo dans le Terminal Série -----------
Serial.println("*** Instructions disponibles pour controle du LCD ***");
Serial.println("blink() : active curseur clignotant");  
Serial.println("noBlink() : inactive curseur clignotant");  

Serial.println("cursor() : active trait sous curseur");  
Serial.println("noCursor() : inactive trait sous curseur");  

Serial.println("clear() : efface ecran et revient en 0,0");
Serial.println("home() : revient en 0,0 sans effacer ecran");

Serial.println("display() : active ecran");
Serial.println("noDisplay() : inactive ecran");

Serial.println("scrollDisplayLeft() : decale ecran et curseur vers gauche");
Serial.println("scrollDisplayRight() : decale ecran et curseur vers droite");


Serial.println("setCursor (colonne,ligne) : positionne curseur en colonne,ligne");  
Serial.println("print(\"chaine\") : affiche chaine a la position actuelle");  



} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()


// --- ici instructions à exécuter par le programme principal ---


//---- Réception chaine sur le port série ---
while (Serial.available()>0) { // tant qu'un octet en réception

        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception==10) { // si Octet reçu est le saut de ligne - activer Newline dans le Terminal
                Serial.println ("Chaine recue="+chaineReception); // affiche la chaine recue
                //chaineReception=""; //RAZ le String de réception
                break; // sort de la boucle while
        }
        else { // si le caractère reçu n'est pas un saut de ligne
                chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
        }

} // fin tant que  octet réception

//----- une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

// ---- analyse de la chaine recue sur le port Série ----
chaineReception=chaineReception.trim(); // enlève les espaces

if (chaineReception=="blink()") lcd.blink(); // blink
if (chaineReception=="noBlink()") lcd.noBlink(); // noblink

if (chaineReception=="cursor()") lcd.cursor(); // cursor
if (chaineReception=="noCursor()") lcd.noCursor(); // noCursor

if (chaineReception=="clear()") lcd.clear(); // clear
if (chaineReception=="home()") lcd.home(); // home

if (chaineReception=="display()") lcd.display(); // display
if (chaineReception=="noDisplay()") lcd.noDisplay(); // noDisplay

if (chaineReception=="scrollDisplayLeft()") lcd.scrollDisplayLeft(); // scrollDisplayLeft()
if (chaineReception=="scrollDisplayRight()") lcd.scrollDisplayRight(); // scrollDisplayRight()

if (chaineReception.substring(0,10)=="setCursor(") { // si reçoit l'instruction setCursor
// nb substring : dernier caractere exclu

  Serial.print("setCursor("); // affiche sur LCD

    //------------- extraction colonne - ligne ------ 2 chiffres
  if (chaineReception.substring(11,12)==",") { // si la virgule en position 11 - càd 1 chiffre

    //---- extraction nombre colonnes - cas 1 seul chiffre
    valeur1=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur1=valeur1-48; // extrait valeur numérique du caractere

    colonne=constrain(valeur1,0,19);//oblige valeur colonne


    Serial.print(colonne); // affiche sur LCD

    Serial.print(","); // affiche sur LCD

    //---- extraction nombre lignes -- 1 seul chiffre
    valeur1=chaineReception.charAt(12); // extrait valeur ASCII du caractere
    valeur1=valeur1-48; // extrait valeur numérique du caractere

    ligne=constrain(valeur1,0,3);// oblige valeur ligne

    Serial.print(ligne); // affiche sur LCD

    Serial.print(")"); // affiche sur LCD

    //---------- si dernier caractere est bien une ) on positionne curseur
    if (chaineReception.substring(13,14)==")") lcd.setCursor(colonne,ligne);

  } // fin si 1 chiffre colonne

  //------------- extraction colonne - ligne ------ 2 chiffres
  if (chaineReception.substring(12,13)==",") { // si la virgule en position 12 - càd 2 chiffres

    valeur1=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur1=valeur1-48; // extrait valeur numérique du caractere

    valeur2=chaineReception.charAt(11); // extrait valeur ASCII du caractere
    valeur2=valeur2-48; // extrait valeur numérique du caractere

    colonne=(valeur1*10)+valeur2;
    Serial.print(colonne); // affiche sur LCD

    Serial.print(","); // affiche sur LCD

    //---- extraction nombre lignes -- 1 seul chiffre
    valeur1=chaineReception.charAt(13); // extrait valeur ASCII du caractere
    valeur1=valeur1-48; // extrait valeur numérique du caractere

    ligne=valeur1;

    Serial.print(ligne); // affiche sur LCD

    Serial.print(")"); // affiche sur LCD

    //---------- si dernier caractere est bien une ) on positionne curseur
    if (chaineReception.substring(14,15)==")") lcd.setCursor(colonne,ligne);

  } // fin si 2 chiffres colonne


} // fin si setCursor


if (chaineReception.substring(0,7)=="print(\"") { // si reçoit l'instruction print("chaine")
// nb substring : dernier caractere exclu

  valeur1=chaineReception.length(); // mémorise longueur de la chaine
  valeur1=valeur1-7-2; // longueur de la chaine texte entre ""

  chaineTest=chaineReception.substring(7,7+valeur1); // extrait la chaine texte
  Serial.println(chaineTest);

  //---- si la chaine est bien suivie du ")
  if (chaineReception.substring(7+valeur1,7+valeur1+2)=="\")") lcd.print(chaineTest);

} // fin si reçoit l'instruction print("chaine")

chaineReception=""; // RAZ String de reception

delay(100); // pause

//while(1); // stop loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////



// ////////////////////////// Fin du programme ////////////////////