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