//*****************************************************************************
// Programme Arduino : ArduinoUnoBoutonTeleMP3_LG_ADXL345_BasicLCD6B
//*****************************************************************************
/*
Écrit par : René Ross
Date : 2013-08-25
Que fait ce programme :
Ce programme utilise la communication I2C pour récupérer les données de base
des trois axes (x, y, et z) d'un capteur accéléromètre LG-ADXL345 et affiche a
toutes les demis-seconde ces données dans le moniteur série de l'éditeur
Arduino et sur l'écran LCD1602 a 6 boutons (un Shield). De plus, il y a
l'utilisation d'un bouton 4 broches et d'un capteur à infrarouge et d'une
télécommande associée pour le contrôle d'une boucle initiale dans la section
« setup () » et l’équivalent dans la section « loop () ». Le taux de
rafraîchissement de 1/2 seconde des valeurs de l'accéléromètre peut-être
modifier avec les boutons « + » et « - » de la télécommande par pas de
0.01 seconde.
L'utilisation des 6 boutons de la carte d'écran LCD1602Sheild est géré :
Le bouton RESET de l'écran LCD est directement relié a la broche ARDUINO_RESET,
, donc du redémarrage du Système complet. Tous les autres boutons (5) sont
listés et ont un effet sur le déroulement de la boucle principale ou sur les
paramètres de fonctionnement de l'écran ou les deux la fois.
En synthèse les boutons font :
_SELECT : Gère l'exécution de la boucle principale du programme.
_UP : Augmente la luminosité du fond d'écran.
_DOWN : Diminue la luminosité du fond d'écran.
_LEFT : Active le paramètre noBlink.
_RIGHT : Active le paramètre blink.
_RST : Redémarrage du Système complet.
*/
/*
Bibliothèques utilisées :
https://arduino.cc/fr/Main/LiquidCrystal
https://github.com/shirriff/Arduino-IRremote
https://arduino.cc/en/Reference/Wire
Autres exemples d'utilisation en date du 6 août 2013 :
https://www.sparkfun.com/tutorials/240
https://www.varesano.net/blog/fabio/exploring-advanced-features-adxl345-accelerometer-single-double-tap-activity-inactivity-f
https://codeyoung.blogspot.ca/2009/11/adxl345-accelerometer-breakout-board.html
https://bildr.org/2011/03/adxl345-arduino/
*/
//*****************************************************************************
// Matériel requis :
//*****************************************************************************
/*
1 x Contrôleur Arduino Uno :
https://arduino.cc/en/Main/ArduinoBoardUno
https://www.atmel.com/devices/atmega328.aspx
https://dx.com/p/funduino-uno-r3-mega328p-board-for-hw-sw-engineers-development-tools-150802
https://dx.com/p/robotale-uno-atmega8u2-development-board-with-usb-cable-blue-178262
https://dx.com/p/uno-r3-development-board-microcontroller-mega328p-atmega16u2-compat-for-arduino-blue-black-215600
1 x Planche d'expérimentation Circuit-Test MB-102J « BreadBoard » :
https://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html
1 x Petit transformateur 110V à 9V, 1A pour Arduino :
https://dx.com/p/arduino-9v-1a-power-adapter-black-2-flat-pin-plug-100cm-cable-126288
1 x Carte a écran LCD LCD1602 6 boutons :
https://www.dfrobot.com/image/data/Common/Arduino%20Shield%20Manual.pdf
https://www.dfrobot.com/image/data/DFR0009/LCD4Bit_mod.zip
https://www.zartronic.fr/doc/E2/E2N1P193/LCD_Keypad_Shield_SCH.pdf
https://www.zartronic.fr/shield-lcd-pour-arduino-p-125.html
https://dx.com/p/lcd-keypad-shield-for-arduino-duemilanove-lcd-1602-118059
1 x Mini télécommande type MP3 :
https://dx.com/p/ir-remote-control-diy-kit-for-arduino-1-x-cr2025-136284
1 x Capteur infra-rouge VS1838B :
https://www.dipmicro.com/store/VS1838B
https://dx.com/s/1838
1 x Condensateur 100uF 10V
1 x Condensateur 104
1 x Résistance 100 Ohm
1 x Résistance 20 KOhm
1 x Bouton-poussoir "Push Button Switches" a 4 pattes :
https://dx.com/p/square-style-electrical-power-control-4-pin-push-button-switches-10-pcs-158030
1 x Capteur accéléromètre LG-ADXL345 avec communication I2C :
https://www.analog.com/ADXL345
https://dx.com/p/adxl345-digital-sensor-acceleration-module-for-arduino-150968
Et des petits câbles électriques et connecteurs appropriés (mâle mâle, femelle
femelle et mâle femelle). Pour référence : MB-940, MB-910, MB-900, MB-102J,
LS-MMPJ-6, LS-FFPJ-6, etc. :
https://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html
https://dx.com/p/breadboard-jumper-cables-wires-for-electronic-diy-100-male-to-male-40-female-to-female-203948
https://dx.com/p/breadboard-jumper-wires-for-electronic-diy-65-cable-pack-118826
https://dx.com/p/male-to-female-dupont-breadboard-jumper-wires-for-arduino-40-piece-pack-20cm-length-146935
https://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
https://dx.com/p/30cm-breadboard-wires-for-electronic-diy-40-cable-pack-80207
https://dx.com/p/2-54mm-1x40-pin-breakaway-straight-male-header-10-piece-pack-144191
https://dx.com/p/breadboard-jumper-wire-cord-kit-for-arduino-diy-140-piece-pack-138220
*/
//*****************************************************************************
//*****************************************************************************
// Circuit à réaliser.
//*****************************************************************************
/*
Dans cette section, toutes les connexions des composantes du montage sont
listé, qu'ils soient utilisés ou non, et cela pour éviter tout oublie et
rendre le copier / coller par bloc complet pour une pièce plus facile d'un
montage à l'autre. Le plus souvent possible le libelle de la pièce précédé du
nom court de la pièce est utilisé, par exemple « ARDUINO_A3 », pour la broche
analogique A3 d'une carte contrôleur Arduino Uno R3.
Plaque d'expérimentation « BreanBoard » :
Pour identifier les broches d'une plaque d'expérimentation « BreanBoard »,
comme dans le jeu de bataille navale "Battle Ship", les lignes sont identifiées
pas des numéro (ici, de 1 a 63) et les colonnes sont identifiées par lettre des
lettres (ici, de a a j) et des signes (+) et (-). Donc (i10) indique
l'intersection de la colonne "i" avec la ligne numéro "10". Pour une broche
des colonnes négatives (-) ou GND et positives (+) ou Vcc, c'est le
signe de la colonne « + » ou « - », suivi du numéro de la rangée (de 1 a 63),
et suivit du côté de la plaque en majuscule, gauche « G » ou droite « D ».
Donc pour la colonne positive de la rangée 3, côté gauche, cela donne (+3G).
Le tout entre parenthèse « ( » et « ) » pour bien spécifier une position de la
planche d'expérimentation et pour éviter toutes confusions.
*/
/*
Câblage de l'Arduino Uno sur une planche d'expérimentation MB-104 :
ARDUINO_USB : Câble USB à l'ordinateur
ARDUINO_PWR12V : Transformateur 110V à 9V ou batteries de 6V~12V
ARDUINO_RESET : ECRAN_LCD_1_RESET
ARDUINO_3_3V :
ARDUINO_5V_1 : ECRAN_LCD_1_VDO
ARDUINO_GND1 : ECRAN_LCD_1_VSS
ARDUINO_GND2 :
ARDUINO_VIN :
ARDUINO_A0 : ECRAN_LCD_1_SELECT
ARDUINO_A1 : ECRAN_LCD_1_UP
ARDUINO_A2 : ECRAN_LCD_1_RIGHT
ARDUINO_A3 : ECRAN_LCD_1_DOWN
ARDUINO_A4_SDA : ECRAN_LCD_1_LEFT
ARDUINO_A5_SCL :
ARDUINO_AREF :
ARDUINO_GND3 :
ARDUINO_13 :
ARDUINO_12 :
ARDUINO_11_PWM :
ARDUINO_10_PWM : ECRAN_LCD_1_A
ARDUINO_9_PWM : ECRAN_LCD_1_E
ARDUINO_8 : ECRAN_LCD_1_RS
ARDUINO_7 : ECRAN_LCD_1_D7
ARDUINO_6_PWM : ECRAN_LCD_1_D6
ARDUINO_5_PWM : ECRAN_LCD_1_D5
ARDUINO_4 : ECRAN_LCD_1_D4
ARDUINO_3_PWM :
ARDUINO_2 :
ARDUINO_1_TX0 :
ARDUINO_0_RX0 :
Câblage directe de la carte a écran LCD LCD1602-6Boutons sur la carte Arduino :
Diagramme : https://www.zartronic.fr/doc/E2/E2N1P193/LCD_Keypad_Shield_SCH.pdf
ECRAN_LCD_1_VSS broche 1 : ARDUINO_GND_?
ECRAN_LCD_1_VDO broche 2 : ARDUINO_5V_1
ECRAN_LCD_1_VO broche 3 : ARDUINO_5V_1
ECRAN_LCD_1_RS broche 4 : ARDUINO_8
ECRAN_LCD_1_RW broche 5 : ARDUINO_GND_?
ECRAN_LCD_1_E broche 6 : ARDUINO_9_PWM
ECRAN_LCD_1_D0 broche 7 :
ECRAN_LCD_1_D1 broche 8 :
ECRAN_LCD_1_D2 broche 9 :
ECRAN_LCD_1_D3 broche 10 :
ECRAN_LCD_1_D4 broche 11 : ARDUINO_4
ECRAN_LCD_1_D5 broche 12 : ARDUINO_5_PWM
ECRAN_LCD_1_D6 broche 13 : ARDUINO_6_PWM
ECRAN_LCD_1_D7 broche 14 : ARDUINO_7
ECRAN_LCD_1_A broche 15 : ARDUINO_10_PWM
ECRAN_LCD_1_K broche 16 : ARDUINO_GND_?
ECRAN_LCD_1_SELECT : ARDUINO_A0
ECRAN_LCD_1_UP : ARDUINO_A0
ECRAN_LCD_1_RIGHT : ARDUINO_A0
ECRAN_LCD_1_DOWN : ARDUINO_A0
ECRAN_LCD_1_LEFT : ARDUINO_A0
ECRAN_LCD_1_RESET : ARDUINO_RESET
ECRAN_LCD_1_J7_6 : ARDUINO_RESET :
ECRAN_LCD_1_J7_5 : ARDUINO_3_3V :
ECRAN_LCD_1_J7_4 : ARDUINO_5V_1, et câble à (+52D)
ECRAN_LCD_1_J7_3 : ARDUINO_GND1, et câble à (-53D)
ECRAN_LCD_1_J7_2 : ARDUINO_GND2 :
ECRAN_LCD_1_J7_1 : ARDUINO_VIN :
ECRAN_LCD_1_J6_5 : ARDUINO_A1 :
ECRAN_LCD_1_J6_4 : ARDUINO_A2 :
ECRAN_LCD_1_J6_3 : ARDUINO_A3 :
ECRAN_LCD_1_J6_2 : ARDUINO_A4_SDA : ACCELEROMETRE_1_SDA, (c48)
ECRAN_LCD_1_J6_1 : ARDUINO_A5_SCL : ACCELEROMETRE_1_SCL, (b47)
ECRAN_LCD_1_J5_7 : ARDUINO_0_RX :
ECRAN_LCD_1_J5_6 : ARDUINO_1_TX :
ECRAN_LCD_1_J5_5 : ARDUINO_2 :
ECRAN_LCD_1_J5_4 : ARDUINO_3_PWM :
ECRAN_LCD_1_J5_3 : ARDUINO_11_PWM :
ECRAN_LCD_1_J5_2 : ARDUINO_12 :
ECRAN_LCD_1_J5_1 : ARDUINO_13 :
ECRAN_LCD_1_ICSP_1 : ARDUINO_12 :
ECRAN_LCD_1_ICSP_2 : ARDUINO_5V_1 :
ECRAN_LCD_1_ICSP_3 : ARDUINO_13 :
ECRAN_LCD_1_ICSP_4 : ARDUINO_11 :
ECRAN_LCD_1_ICSP_5 : ARDUINO_RESET :
ECRAN_LCD_1_ICSP_5 : ARDUINO_GND_? :
Câblage pour le capteur infra-rouge utiliser avec la télécommande, sur la
planche d'expérimentation :
CAPTEUR_IR_1_SORTIE broche 1 : (f57) et câble de (j57) à ECRAN_LCD_1_J5_4
CAPTEUR_IR_1_GND broche 2 : (f58) et câble de (j58) à (-58D)
CAPTEUR_IR_1_VIN broche 3 : (f59)
Condensateur 104 broche 1 : (g58)
Condensateur 104 broche 2 : (g59)
Condensateur 100uF 10V- : (h58)
Condensateur 100uF 10V+ : (h59)
Résistance 100 Ohm 1 : (j59)
Résistance 100 Ohm 2 : (+59D)
Résistance 20 KOhm 1 : (i57)
Résistance 20 KOhm 2 : (i59)
Câblage pour le gros bouton sur la planche d'expérimentation :
BOUTON_1Broche_1 : (d61)
BOUTON_1Broche_2 : (d63)
BOUTON_1Broche_3 : (g63) et câble de (i63) à ECRAN_LCD_1_J5_5
BOUTON_1Broche_4 : (g61) et câble de (j61) à (+61D)
Résistance 100 Ohm 1 : (j63)
Résistance 100 Ohm 2 : (-61D)
Câblage pour le module LG-ADXL345 en i2c, sur la la planche d'expérimentation :
ACCELEROMETRE_1_SCL broche 1 : (a41) et câble de (b41) à (b47) ECRAN_LCD_1_J6_1
ACCELEROMETRE_1_SDA broche 2 : (a42) et câble de (c42) à (c48) ECRAN_LCD_1_J6_2
ACCELEROMETRE_1_SDO broche 3 :
ACCELEROMETRE_1_INT2 broche 4 :
ACCELEROMETRE_1_INT1 broche 5 :
ACCELEROMETRE_1_CS broche 6 : (i45) et câble de (j45) à (+45D)
ACCELEROMETRE_1_VS broche 7 :
ACCELEROMETRE_1_GND broche 8 : (i43) et câble de (j43) à (-43D)
ACCELEROMETRE_1_3V3 broche 9 :
ACCELEROMETRE_1_5V broche 10 : (i41) et câble de (j41) à (+41D)
*/
//*****************************************************************************
//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
#include <LiquidCrystal.h>
/*
« Cette librairie permet à une carte Arduino de contrôler un afficheur LCD
alphanumérique standard à cristaux liquides basé sur le circuit intégré Hitachi
HD44780 (ou compatible), ce qui est le cas de la plupart des afficheurs
alphanumériques LCD disponibles. La librairie fonctionne aussi bien en mode 4
bits qu'en mode 8 bits (càd utilisant 4 ou 8 broches numériques en plus des
broches de contrôle RS, Enable et RW (optionnel)). Ainsi, en mode 4 bits,
6 broches numériques de la carte Arduino suffisent pour contrôler un afficheur
LCD alphanumérique.
Référence : https://arduino.cc/fr/Main/LibrairieLCD
*/
#include <IRremote.h>
/*
Il s'agit de la bibliothèque irRemote pour l'Arduino.
Pour télécharger depuis github :
https://github.com/shirriff/Arduino-IRremote
Cliquez sur le lien "Télécharger" en haut à droite, cliquez sur « Télécharger
au format Zip", pour obtenir un fichier zip. Décompressez-le et renommez le
répertoire « Shirriff-Arduino-irRemote-NNN » pour « irRemote ». Pour
l'installer, déplacer le répertoire de irRemote téléchargée dans votre dossier
des bibliothèque Arduino « ~/Arduino/libraries/IRremote ». Pour avoir accès à la
nouvelle bibliothèque, vous devez redémarrer l'éditeur Arduino. Pour plus de
détails sur la bibliothèque voir le wiki sur github ou le poste :
https://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html blog
Copyright 2009-2012 Ken Shirriff
Merci à cette personne pour sa contribution !
*/
#include <Wire.h>
/*
Cette bibliothèque vous permet de communiquer avec des périphériques I2C/TWI.
Sur les cartes Arduino révision R3, les broches SDA (ligne de données) et SCL
(ligne d'horloge) sont à proximité de la broche AREF.
En référence le tableau ci-dessous montre ont situés les broches avec les cartes
Arduino.
Carte Broches I2C / TWI
Uno, Ethernet A4 (SDA), A5 (SCL)
Mega2560 20 (SDA), 21 (SCL)
Leonardo 2 (SDA), 3 (SCL)
Due 20 (SDA), 21 (SCL), SDA1, SCL1
Avec Arduino version 1.0 et plus, la bibliothèque hérite des fonctions de flux,
ce qui rend compatible avec les autres bibliothèques en lecture/écriture. Pour
cette raison, « send () » et « receive () » ont été remplacés par « read () » et
« write () ».
Remarque :
Il y a deux variante d'adresse de communication I2C, une de 7 bits et une de
8 bits. La variante 7 bits identifier le dispositif et le huitième bit
détermine si elle est en cours d'écriture ou de lecture à partir. La
bibliothèque de fil utilise des adresses 7 bits partout. Si vous avez un code
de fiche ou d'échantillon qui utilise 8 bits d'adresse, vous aurez besoin de
laisser tomber le bit bas, c'est a dire, de décaler la valeur d'un bit vers la
droite), ce qui donne une adresse entre 0 et 127.
Référence : https://arduino.cc/en/Reference/Wire
*/
//*****************************************************************************
//*****************************************************************************
// Déclaration des constantes.
//*****************************************************************************
/*
Par convention, pour nommer une constante, nous utiliserons des noms écrits
tout en majuscule, en capitale, ce qui facilitera leur repérage et rendra le
code plus facilement compréhensible. Le mot devant notre nom de constante
indique à l'Arduino l'espace mémoire à réserver pour stocker cette donnée.
Après le nom de notre constante, on lui attribue sa valeur.
*/
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE » est l'équivalent du paramètre « INPUT ». Ce paramètre
est pour prépare l'Arduino a recevoir une tension électrique pour ce
connecteur, sur ce port de communication, sur ce "pin".
*/
const byte ENTREE = INPUT;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE_ET_RESISTENCE_INTERNE » est l'équivalent du paramètre
« INPUT_PULLUP ». Ce paramètre est pour prépare l'Arduino en activant sa
résistance interne et a recevoir une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/
const byte ENTREE_ET_RESISTENCE_INTERNE = INPUT_PULLUP;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « SORTIE » est l'équivalent du paramètre « OUTPUT ». Ce paramètre
est pour prépare l'Arduino a émettre une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/
const byte SORTIE = OUTPUT;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « HAUT » est l'équivalent du paramètre « HIGH ». Ce paramètre fait
que l'Arduino maintiendra un voltage haut sur ce connecteur, soit 3.3 Volts,
soit 5 Volts, selon sa propre tension d'alimentation. En électronique, cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/
const byte HAUT = HIGH;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « BAS » est l'équivalent du paramètre « LOW ». Ce paramètre fait
que l'Arduino maintiendra un voltage bas sur ce connecteur, soit 0 Volt. En
électronique, cela correspondra aux valeurs logiques « 0 », « Non », ou
« Faut », etc.
*/
const byte BAS = LOW;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « NON » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », ou « Faut », etc.
*/
const byte NON = false;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « OUI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/
const byte OUI = true;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « FAUX » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », etc.
*/
const byte FAUX = false;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « VRAI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », etc.
*/
const byte VRAI = true;
//*****************************************************************************
//*****************************************************************************
// Constantes des connecteurs.
//*****************************************************************************
// Pour gérer l'action d'humains le bouton de la planche d'expérimentation.
const int BOUTON_1_SORTIE = 2;
// Broche d'Arduino pour recevoir le signale du capteur infrarouge.
const int CAPTEUR_IR_1_SORTIE = 3;
// Pour Activer et Déactiver la DEL sur le contrôleur Arduino.
const int ARDUINO_DEL = 13;
// Broche d'Arduino pour communication I2C avec accéléromètre LG-ADXL345.
const int ACCELEROMETRE_1_SCL = A5;
const int ACCELEROMETRE_1_SDA = A4;
// Constantes des broches sur l'Arduino pour une carte LCD1602.
const byte ECRAN_LCD_1_RS = 8;// Écran LCD.
const byte ECRAN_LCD_1_E = 9;// Écran LCD.
const byte ECRAN_LCD_1_D4 = 4;// Écran LCD.
const byte ECRAN_LCD_1_D5 = 5;// Écran LCD.
const byte ECRAN_LCD_1_D6 = 6;// Écran LCD.
const byte ECRAN_LCD_1_D7 = 7;// Écran LCD.
const byte ECRAN_LCD_1_A = 10;// Écran LCD contrôle la luminosité arrière.
const byte ECRAN_LCD_1_SELECT = A0;// Carte écran LCD 1 boutons
const byte ECRAN_LCD_1_UP = A0;// Carte écran LCD 2 boutons
const byte ECRAN_LCD_1_RIGHT = A0;// Carte écran LCD 3 boutons
const byte ECRAN_LCD_1_DOWN = A0;// Carte écran LCD 4 boutons
const byte ECRAN_LCD_1_LEFT = A0;// Carte écran LCD 5 boutons
const byte ECRAN_LCD_1_BOUTONS = A0;// Pour la gestion des boutons
// Constantes des paramètres de l'objet ECRAN_LCD.
// Nombre de lignes et de colonnes.
const byte ECRAN_LCD_1_NOMBRE_DE_COLONNES = 16;
const byte ECRAN_LCD_1_NOMBRE_DE_LIGNES = 2;
// Par le passage d'une résistance, la valeur indiquant le bon bouton pressé.
const int ECRAN_LCD_1_VALEUR_SELECT = 800;
const int ECRAN_LCD_1_VALEUR_UP = 200;
const int ECRAN_LCD_1_VALEUR_RIGHT = 100;
const int ECRAN_LCD_1_VALEUR_DOWN = 400;
const int ECRAN_LCD_1_VALEUR_LEFT = 600;
// Aucun bouton n'est pressé.
const int ECRAN_LCD_1_VALEUR_AUCUN = 1023;
//*****************************************************************************
//*****************************************************************************
// Variables des paramètres et de travaille des objets.
//*****************************************************************************
// Initialisation des fonctionnalités utilisées.
//*****************************************************************************
// Initialisation LCD en mode 4 bits.
//*****************************************************************************
LiquidCrystal EcranLCD_1 (ECRAN_LCD_1_RS,
ECRAN_LCD_1_E,
ECRAN_LCD_1_D4,
ECRAN_LCD_1_D5,
ECRAN_LCD_1_D6,
ECRAN_LCD_1_D7);
//*****************************************************************************
//*****************************************************************************
// Déclaration des variables globales.
//*****************************************************************************
/*
Par convention, pour nommer une variable, nous utiliserons des noms écrits
avec un majuscule pour la première lettre de chaque mot composant le nom de la
variable, ce qui facilitera leur repérage et rendra le code plus facilement
compréhensible. Le mot devant notre nom de variable indique à l'Arduino l'espace
mémoire à réserver pour stocker cette donnée. Après le nom de notre variable, on
lui attribue sa valeur.
*/
/*
Ici, nous définissons la variable qui contrôlera la grande boucle principale,
qui s'active avec le bouton « Power » de la télécommande. Par défaut, le robot
ne fait rien a l’exception d'initialiser ses périphériques.
*/
boolean Boucler = NON;
// Pour la fonction « delay », qui compte le temps en milliseconde.
int UneSeconde = 1000;
// Délai pour réduire la vitesse de réaction entre les lectures des boutons.
int TempsRebonBouton = 5;
/*
Définition de la valeur retourné par les boutons de la télécommande.
*/
const unsigned long TelecommandeBoutonPower = 16753245;
const unsigned long TelecommandeBoutonMode = 16736925;
const unsigned long TelecommandeBoutonSon = 16769565;
const unsigned long TelecommandeBoutonPlayPause = 16720605;
const unsigned long TelecommandeBoutonDebut = 16712445;
const unsigned long TelecommandeBoutonFin = 16761405;
const unsigned long TelecommandeBoutonEQ = 16769055;
const unsigned long TelecommandeBoutonMoins = 16754775;
const unsigned long TelecommandeBoutonPlus = 16748655;
const unsigned long TelecommandeBouton0 = 16738455;
const unsigned long TelecommandeBoutonRecycle = 16750695;
const unsigned long TelecommandeBoutonU_SD = 16756815;
const unsigned long TelecommandeBouton1 = 16724175;
const unsigned long TelecommandeBouton2 = 16718055;
const unsigned long TelecommandeBouton3 = 16743045;
const unsigned long TelecommandeBouton4 = 16716015;
const unsigned long TelecommandeBouton5 = 16726215;
const unsigned long TelecommandeBouton6 = 16734885;
const unsigned long TelecommandeBouton7 = 16728765;
const unsigned long TelecommandeBouton8 = 16730805;
const unsigned long TelecommandeBouton9 = 16732845;
// Pour contenir la valeur du dernier bouton pressé.
unsigned long TelecommandeBoutonValeur = 0;
// Adresses de communication I2C avec accéléromètre ADXL345.
const char Accellerometre3AxesAdresse = 0x53;
byte Accellerometre3AxesMemoire [6];
const char POWER_CTL = 0x2D;// Registre "Power Control".
const char DATA_FORMAT = 0x31;// Registre "Data Format".
const char DATAX0 = 0x32;//X-Axis Data 0
const char DATAX1 = 0x33;//X-Axis Data 1
const char DATAY0 = 0x34;//Y-Axis Data 0
const char DATAY1 = 0x35;//Y-Axis Data 1
const char DATAZ0 = 0x36;//Z-Axis Data 0
const char DATAZ1 = 0x37;//Z-Axis Data 1
const char Accellerometre_1_Precision2G = 0x00;
const char Accellerometre_1_Precision4G = 0x01;
const char Accellerometre_1_Precision8G = 0x02;
const char Accellerometre_1_Precision16G = 0x03;
const char Accellerometre_1_ModeMesure = 0x08;
// Pour recevoir les valeurs des 3 axes de l'accéléromètre.
int Accelerometre1_AxeX = 0;
int Accelerometre1_AxeY = 0;
int Accelerometre1_AxeZ = 0;
// Variable recevant la valeur du bouton pressé, entre 0 et 1023.
int EcranLCD_1Bouton = 0;
// Modifié de ±5 par le bouton Up/Down.
int EcranLCD_1FondEcranValeur = 100;
// Modifié de ±0.1 seconde le taux de rafraîchissement des données (+/-).
int TauxRafraichissementDonnees = (UneSeconde / 2);
//*****************************************************************************
//*****************************************************************************
// Création en mémoire des objet pour les interfaces des périphériques.
//*****************************************************************************
// Pour le capteur infrarouge crée un objet sur la broche voulue.
IRrecv Capteur_IR_1 (CAPTEUR_IR_1_SORTIE);
decode_results Capteur_IR_1_Results;
// ...
//*****************************************************************************
//*****************************************************************************
// FONCTION SETUP = Code d'initialisation.
//*****************************************************************************
/*
La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du
programme. Pour éviter de mettre des composantes sous tension avec la dernière
version du programme chargé dans l'Arduino, Nous utilisant une boucle « while »,
tant qu'une première action n'est pas accompli par l'utilisateur, on ne fait
rien (Télécommande, bouton, etc.).
L'activation du rappel au + interne des connecteurs en entrée si nécessaire.
L'instruction « digitalWrite (pin, HIGH); » écrit la valeur HIGH, qui vaux 1
sur le connecteur en entrée, ce qui active la résistance de "rappel au +"
(pullup) au plus de ce connecteur. L'utilisation de cette résistance interne
est une protection minimale pour l'intégrité physique pour la puce principale.
*/
void setup ()
{
// Ici les instructions à exécuter au démarrage.
// IMPORTANT : régler le terminal côté PC avec la même valeur de
// transmission. Ici c'est 115200.
Serial.begin (115200);
// Pour affichage dans le moniteur série de l'éditeur Arduino.
Serial.print ("********************************************************");
Serial.println ();
Serial.print ("* Debut de la procedure d'initialisation du systeme... *");
Serial.println ();
Serial.print ("********************************************************");
Serial.println ();
Serial.print ("* Attente du bouton (Power) de la telecommande... *");
Serial.println ();
Serial.print ("********************************************************");
Serial.println ();
Serial.println ();
// Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
// Configurer le port Arduino en entrée pour le bouton 1.
pinMode (ECRAN_LCD_1_BOUTONS, ENTREE);
digitalWrite (ECRAN_LCD_1_BOUTONS, HAUT);
pinMode (ECRAN_LCD_1_A, SORTIE);
analogWrite (ECRAN_LCD_1_A, EcranLCD_1FondEcranValeur);
// Pour affichage dans l'écran LCD.
EcranLCD_1.begin (ECRAN_LCD_1_NOMBRE_DE_COLONNES, ECRAN_LCD_1_NOMBRE_DE_LIGNES);
EcranLCD_1.clear ();
EcranLCD_1.cursor ();
EcranLCD_1.setCursor (0,0);
EcranLCD_1.print ("Bouton (SELECT)!");
// Connecteurs en entrées et sorties.
// Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
// Configurer le port Arduino en entrée pour le bouton.
pinMode (BOUTON_1_SORTIE, ENTREE);
// Activer la résistance au plus PULLUP.
digitalWrite (BOUTON_1_SORTIE, HAUT);
// Configurer le port Arduino en entrée pour le capteur infrarouge.
pinMode (CAPTEUR_IR_1_SORTIE, ENTREE);
// Initialisation et début de la réception du capteur infrarouge.
Capteur_IR_1.enableIRIn ();
// Boucle pour éviter qu'un ancien programme chargé ne s'exécute avec un
// nouveau montage installé, en attente du chargement du nouveau programme.
// Jusqu'ici, c'est le minimum qui est activé, le reste des connexions
// seront activé après la boucle d'attente.
while (Boucler != OUI)
{
// Gérer le bouton Marche/Arrêt sur la planche d'expérimentation.
GererBoutonMarcheArret ();
// Gérer les boutons de la télécommande infrarouge.
GererBoutonTeleCommande ();
// Gérer les boutons de la carte d'écran LCD.
GererBoutonEcranLCD ();
}
// Active la DEL de l'Arduino.
pinMode (ARDUINO_DEL, SORTIE);
digitalWrite (ARDUINO_DEL, Boucler);
// Initialisation de la communication I2C bus pour le capteur d’accélération.
Wire.begin ();
// Mettre le ADXL345 à plage +/-4G en écrivant la valeur 0x01 dans le
// registre DATA_FORMAT.
AccellerometreConfigure (DATA_FORMAT, Accellerometre_1_Precision4G);
// Mettre le ADXL345 en mode de mesure en écrivant 0x08 dans le registre
// POWER_CTL.
AccellerometreConfigure (POWER_CTL, Accellerometre_1_ModeMesure);
// Pour affichage dans le moniteur série de l'éditeur Arduino.
Serial.print ("********************************************************");
Serial.println ();
Serial.print ("* Fin de la procedure d'initialisation du systeme... *");
Serial.println ();
Serial.print ("********************************************************");
Serial.println ();
Serial.println ();
// Pour affichage dans l'écran LCD.
EcranLCD_1.clear ();
EcranLCD_1.noCursor ();// Cache le curseur
EcranLCD_1.setCursor (0,0);
EcranLCD_1.print (">>>>>> OK <<<<<<");
EcranLCD_1.setCursor (0,1);
EcranLCD_1.print ("Touche # et /");
}
//*****************************************************************************
//*****************************************************************************
// 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()
{
// Ici les instructions à exécuter par le programme principal.
// Gérer le bouton Marche/Arrêt sur la planche d'expérimentation.
GererBoutonMarcheArret ();
// Gérer les boutons de la télécommande infrarouge.
GererBoutonTeleCommande ();
// Gérer les boutons de la carte d'écran LCD.
GererBoutonEcranLCD ();
if (Boucler == OUI)
{
// Pour affichage dans le moniteur série de l'éditeur Arduino.
AccellerometreLecture ();
Serial.print (" AxeX:");
Serial.print (Accelerometre1_AxeX);
Serial.println ();
Serial.print (" AxeY:");
Serial.print (Accelerometre1_AxeY);
Serial.println ();
Serial.print (" AxeZ:");
Serial.print (Accelerometre1_AxeZ);
Serial.println ();
Serial.print (" TauxRafraichissementDonnees:");
Serial.print (TauxRafraichissementDonnees);
Serial.println ();
Serial.print (" EcranLCD_1FondEcranValeur:");
Serial.print (EcranLCD_1FondEcranValeur);
Serial.println ();
Serial.println ();
EcranLCD_1.clear ();
EcranLCD_1.setCursor (0,0);
EcranLCD_1.print ("Accel. Raf.:");
EcranLCD_1.print (TauxRafraichissementDonnees);
EcranLCD_1.setCursor (0,1);
EcranLCD_1.print ("x");
EcranLCD_1.print (Accelerometre1_AxeX);
EcranLCD_1.setCursor (6,1);
EcranLCD_1.print ("y");
EcranLCD_1.print (Accelerometre1_AxeY);
EcranLCD_1.setCursor (12,1);
EcranLCD_1.print ("z");
EcranLCD_1.print (Accelerometre1_AxeZ);
delay (TauxRafraichissementDonnees);
}
}
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
//***************************** Fin du programme. *****************************
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
// FONCTION GererBoutonMarcheArret
//*****************************************************************************
/*
Gestion de l'utilisation d'un bouton sur la planche d'expérimentation.
*/
void GererBoutonMarcheArret ()
{
int EtatBouton = digitalRead (BOUTON_1_SORTIE);
if (EtatBouton == HAUT)
{
Serial.print ("Le bouton Marche Arret enclenche");
Serial.println ();
if (Boucler == OUI)
{
Boucler = NON;
// Éteindre la DEL de l'Arduino.
digitalWrite (ARDUINO_DEL, Boucler);
Serial.print ("En attente d'une action d'humaine");
Serial.println ();
}
else
{
Boucler = OUI;
// Allumer la DEL de l'Arduino.
digitalWrite (ARDUINO_DEL, Boucler);
Serial.print ("Poursuite du programme");
Serial.println ();
}
while (EtatBouton == HAUT)
{
// Pour absorber les micro-coupures des rebonds (minimum 5 ms).
delay (TempsRebonBouton);
EtatBouton = digitalRead (BOUTON_1_SORTIE);
}
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererBoutonTeleCommande
//*****************************************************************************
/*
Gérer l'utilisation d'une télécommande type MP3 avec capteur infrarouge.
Ici tous les boutons de la télécommande sont listés et pourraient avoir un
effet sur le déroulement de de la boucle principale ou sur les paramètres de
fonctionnement du moteur ou les deux la fois et la touche « Mode » est
l'actionneur de la broche RESET de la carte Arduino, donc du redémarrage du
Système complet.
En synthèse les boutons font :
Power : Active/désactive la boucle principale du programme, arrêt moteur.
Mode : Bouton kamikaze qui utilise la broche RESET de la carte Arduino.
Son :
PlayPause :
Debut :
Fin :
EQ :
Moins : Le taux de rafraîchissement est diminué de 0.01 seconde.
Plus : Le taux de rafraîchissement est augmenté de 0.01 seconde.
0 :
Recycle :
U_SD :
1 :
2 :
3 :
4 :
5 :
6 :
7 :
8 :
9 :
default : Une télécommande génère beaucoup d'autres codes qui sont inutiles ici.
*/
void GererBoutonTeleCommande ()
{
if (Capteur_IR_1.decode (&Capteur_IR_1_Results))
{
Capteur_IR_1.resume (); // Récupérer la valeur suivante.
TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
switch (TelecommandeBoutonValeur)
{
case TelecommandeBoutonPower:
Serial.print (" TelecommandeBoutonPower : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
if (Boucler == OUI)
{
Boucler = NON;
digitalWrite (ARDUINO_DEL, Boucler);
Serial.print ("En attente d'une action d'humaine");
Serial.println ();
digitalWrite (ARDUINO_DEL, Boucler);
}
else
{
Boucler = OUI;
digitalWrite (ARDUINO_DEL, Boucler);
Serial.print ("Poursuite du programme");
Serial.println ();
digitalWrite (ARDUINO_DEL, Boucler);
}
break;
/* La carte d'extention de l'écran LCD1602 a déjà un bouton RESET...
case TelecommandeBoutonMode:
Serial.print (" TelecommandeBoutonMode : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
Serial.print (" Redemarrage du controleur Arduino!! ");
Serial.println ();
delay (UneSeconde);
// Configurer le port Arduino pour un RESET par télécommande.
pinMode (ARDUINO_RESET, SORTIE);
// Activer la broche ARDUINO_RESET.
digitalWrite (ARDUINO_RESET, BAS);
delay (UneSeconde);
break;
*/
case TelecommandeBoutonSon:
Serial.print (" TelecommandeBoutonSon : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonPlayPause:
Serial.print (" TelecommandeBoutonPlayPause : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonDebut:
Serial.print (" TelecommandeBoutonDebut : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonFin:
Serial.print (" TelecommandeBoutonFin : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonEQ:
Serial.print (" TelecommandeBoutonEQ : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonMoins:
Serial.print (" TelecommandeBoutonMoins : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
TauxRafraichissementDonnees = (TauxRafraichissementDonnees - 10);
break;
case TelecommandeBoutonPlus:
Serial.print (" TelecommandeBoutonPlus : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
TauxRafraichissementDonnees = (TauxRafraichissementDonnees + 10);
break;
case TelecommandeBouton0:
Serial.print (" TelecommandeBouton0 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonRecycle:
Serial.print (" TelecommandeBoutonRecycle : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBoutonU_SD:
Serial.print (" TelecommandeBoutonU_SD : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton1:
Serial.print (" TelecommandeBouton1 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton2:
Serial.print (" TelecommandeBouton2 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton3:
Serial.print (" TelecommandeBouton3 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton4:
Serial.print (" TelecommandeBouton4 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton5:
Serial.print (" TelecommandeBouton5 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton6:
Serial.print (" TelecommandeBouton6 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton7:
Serial.print (" TelecommandeBouton7 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton8:
Serial.print (" TelecommandeBouton8 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
case TelecommandeBouton9:
Serial.print (" TelecommandeBouton9 : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
break;
default:
Serial.print (" Code inconnu : ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
}
}
while (Capteur_IR_1.decode (&Capteur_IR_1_Results))
{
// Pour absorber les micro-coupures des rebonds (minimum 5 ms).
delay (TempsRebonBouton);
Capteur_IR_1.resume (); // Récupéré la valeur suivante.
TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererBoutonEcranLCD
//*****************************************************************************
void GererBoutonEcranLCD ()
/*
Gérer l'utilisation de 5 des 6 bouton de la carte LCD1602Sheild.
Le bouton RESET de l'écran LCD est directement relié a la broche ARDUINO_RESET,
, donc du redémarrage du Système complet. Tous les autres boutons (5) sont
listés et ont un effet sur le déroulement de la boucle principale ou sur les
paramètres de fonctionnement de l'écran ou les deux la fois.
En synthèse les boutons font :
_SELECT : Gère l'exécution de la boucle principale du programme.
_UP : Augmente la luminosité du fond d'écran.
_DOWN : Diminue la luminosité du fond d'écran.
_LEFT : Active le paramètre noBlink.
_RIGHT : Active le paramètre blink.
_RST : Redémarrage du Système complet.
*/
{
EcranLCD_1Bouton = analogRead (ECRAN_LCD_1_BOUTONS);
if (EcranLCD_1Bouton == ECRAN_LCD_1_VALEUR_AUCUN)
{
}
else if (EcranLCD_1Bouton < ECRAN_LCD_1_VALEUR_RIGHT)
{
EcranLCD_1.blink ();// Fait clignoter le curseur
Serial.println (EcranLCD_1Bouton);
}
else if (EcranLCD_1Bouton < ECRAN_LCD_1_VALEUR_UP)
{
EcranLCD_1FondEcranValeur = constrain ((EcranLCD_1FondEcranValeur+5),0,255);
analogWrite (ECRAN_LCD_1_A, EcranLCD_1FondEcranValeur);
Serial.println (EcranLCD_1Bouton);
Serial.print ("EcranLCD_1FondEcranValeur = ");
Serial.print (EcranLCD_1FondEcranValeur);
Serial.println ();
}
else if (EcranLCD_1Bouton < ECRAN_LCD_1_VALEUR_DOWN)
{
EcranLCD_1FondEcranValeur = constrain ((EcranLCD_1FondEcranValeur-5),0,255);
analogWrite (ECRAN_LCD_1_A, EcranLCD_1FondEcranValeur);
Serial.println (EcranLCD_1Bouton);
Serial.print ("EcranLCD_1FondEcranValeur = ");
Serial.print (EcranLCD_1FondEcranValeur);
Serial.println ();
}
else if (EcranLCD_1Bouton < ECRAN_LCD_1_VALEUR_LEFT)
{
EcranLCD_1.noBlink ();// Arrête le clignotement du curseur
Serial.println (EcranLCD_1Bouton);
}
else if (EcranLCD_1Bouton < ECRAN_LCD_1_VALEUR_SELECT)
{
Boucler = 1 - Boucler;
Serial.println (EcranLCD_1Bouton);
}
// Attendre la relâche de la touche.
while (EcranLCD_1Bouton != ECRAN_LCD_1_VALEUR_AUCUN)
{
// Absorber les micro-coupures des rebonds (5 ms).
delay (5);
// Récupérer la valeur suivante.
EcranLCD_1Bouton = analogRead (ECRAN_LCD_1_BOUTONS);
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION AccellerometreConfigure
//*****************************************************************************
void AccellerometreConfigure (byte address, byte val)
{
// Commencer la transmission à trois axes accéléromètre
Wire.beginTransmission (Accellerometre3AxesAdresse);
// Envoyer l'adresse de registre
Wire.write (address);
// Envoyer la valeur à écrire.
Wire.write (val);
// Fin de la transmission.
Wire.endTransmission ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION AccellerometreLecture ()
//*****************************************************************************
void AccellerometreLecture ()
{
uint8_t NombreOctets_a_Lire = 6;
// Lire les données d'accélération à partir du module ADXL345.
AccellerometreLectureMemoire (DATAX0, NombreOctets_a_Lire,
Accellerometre3AxesMemoire);
// Chaque lecture de l'axe vient dans une résolution de 10 bits, soit 2 octets.
// Première Octet significatif !
// Donc nous convertissons les deux octets pour un « int ».
Accelerometre1_AxeX = (((int)Accellerometre3AxesMemoire[1]) << 8) |
Accellerometre3AxesMemoire[0];
Accelerometre1_AxeY = (((int)Accellerometre3AxesMemoire[3]) << 8) |
Accellerometre3AxesMemoire[2];
Accelerometre1_AxeZ = (((int)Accellerometre3AxesMemoire[5]) << 8) |
Accellerometre3AxesMemoire[4];
}
//*****************************************************************************
//*****************************************************************************
// FONCTION AccellerometreLectureMemoire
//*****************************************************************************
/*
Lit le nombre d'octets à partir du registre d'adresse sur accéléromètre dans le
tableau en mémoire de l'accéléromètre.
*/
void AccellerometreLectureMemoire (byte address, int num, byte
Accellerometre3AxesMemoire[])
{
// Démarrer la transmission à accéléromètre.
Wire.beginTransmission (Accellerometre3AxesAdresse);
// Envoie l'adresse de lire.
Wire.write (address);
// Fin de la transmission.
Wire.endTransmission ();
// Démarrer la transmission à accéléromètre.
Wire.beginTransmission (Accellerometre3AxesAdresse);
// Demande 6 octets à l'accéléromètre.
Wire.requestFrom (Accellerometre3AxesAdresse, num);
int i = 0;
// L'accéléromètre peut envoyer moins que demandé, c'est anormal, mais...
while (Wire.available())
{
// Recevoir un octet.
Accellerometre3AxesMemoire[i] = Wire.read ();
i++;
}
// Fin de la transmission.
Wire.endTransmission ();
}
//*****************************************************************************
//*****************************************************************************
// Mémo instructions
//*****************************************************************************
// Mémo LCD
//*****************************************************************************
/*
LiquidCrystal EcranLCD_1 (rs, enable, d4, d5, d6, d7);// Initialisation 4 bits
EcranLCD_1.begin (cols, rows);// Initialisation nombre colonne/ligne
EcranLCD_1.clear ();// Efface écran et met le curseur en haut à gauche
EcranLCD_1.home ();// Repositionne le curseur en haut et à gauche SANS effacer écran
EcranLCD_1.setCursor (col, row);// Positionne le curseur à l'endroit voulu (0, 0)
EcranLCD_1.print ("texte");// Affiche la chaîne texte
EcranLCD_1.cursor ();// Affiche la ligne de base du curseur
EcranLCD_1.noCursor ();// Cache le curseur
EcranLCD_1.blink ();// Fait clignoter le curseur
EcranLCD_1.noBlink ();// Arrête le clignotement du curseur
EcranLCD_1.noDisplay ();// Éteint le LCD sans modifier l'affichage
EcranLCD_1.display ();// Rallume le LCD sans modifier l'affichage
EcranLCD_1.scrollDisplayLeft ();// Décale l'affichage d'une colonne vers la gauche
EcranLCD_1.scrollDisplayRight ();// Décale l'affichage d'une colonne vers la droite
EcranLCD_1.autoscroll ();// Les nouveaux caractères poussent les caractères déjà affichés
EcranLCD_1.noAutoscroll ();// Stoppe le mode autoScroll
*/
//*****************************************************************************