P 44

Mthodes de la bibliothque arduino-pinchangeint.h.

Note place en page sur les interruptions dans SYNTAXE.
NOTE : Les ATMega328 peuvent galement grer des interruptions
de changement dtat sur vingt de leurs broches. Mais leur traitement
nest pas aussi simple que pour les interruptions externes car il faut
aiguiller le code aprs avoir dtermin d'ou vient le requte. La
librairie Arduino arduino-pinchangeint.h a t dveloppe afin
de permettre lutilisation de ces interruptions internes au P.
Synthse d'utilisation des diverses bibliothques.
Librairie Serial : Communications srie USB avec la carte Arduino.
Wire.h : Protocoles de communication Arduino par ligne I2C / TWI.
I2Cdev.h : Complte Wire.h pour des C.I. lectroniques spcifiques.
EEPROM.h : Lire et crire dans l'EEPROM du P d'Arduino.
LedControl.h : Gestion par la SPI d'un multiplexeur type MAX7219.
Servo.h : Pilotage angulaire de servomoteurs par PWM.
Stepper.h : Pilotage "direct" des bobines d'un moteur pas pas.
AFMotor.h : Gestion d'une carte lectronique ADAFRUIT motors.
LES BIBLIOTHQUES
TABLE DES MATIRES
Bibliothque Serial pour la communication srie. ............................ P02
Mthodes de la bibliothque Wire.h. ................................................ P04
Complments relatifs la bibliothque Wire.h. ................................ P05
Mthodes de la bibliothque EEPROM.h. ........................................ P05
La bibliothque I2Cdev.h. ................................................................. P06
Mthodes de la bibliothque LedControl.h. ...................................... P07
La bibliothque SD.h. ...................................................................... P08
Mthodes de la bibliothque Servo.h. .............................................. P14
Mthodes de la bibliothque Stepper.h.. .......................................... P15
Mthodes de la bibliothque AFMotor.h ........................................ P16
La bibliothque complmentaire AccelStepper.h. ......................... P19

Page 1
AccelStepper.h : Complment de Stepper.h > Voir page 15. Mthodes de la bibliothque LiquidCrystal.h. ................................... P20
LiquidCrystal.h : Gestion d'afficheurs LCD avec "chipset HD44780". Mthodes de la bibliothque Perso_ST7565.h............................... P23
Perso_ST7565.h : Gestion de l'afficheur rtroclair RBV ST7565.
Mthodes de la bibliothque Adafruit_ssd1306syp.h. .................... P30
Adafruit_ssd1306syp.h : Gestion de l'afficheur OLED 128 x 64.
avr/eeprom.h : Remplace avantageusement EEPROM.h. Mthodes de la bibliothque avr/eeprom.h.................................... P32
avr/pgmspace.h : Stocker des constantes en mmoire de programme. Mthodes de la bibliothque avr/pgmspace.h. .............................. P34
SD.h : Permet de lire et d'crire sur des cartes mmoires SD et SDHC. CRER UNE BIBLIOTHQUE PERSONNELLE : ........................... P37
TERMINOLOGIE. Le format pde pour les fichiers source. ............................................ P41
Bibliothque : Ensemble de procdures utilitaires grant un domaine IMPORTER UNE BIBLIOTHQUE : ................................................. P42
de la programmation, et mises disposition des utilisateurs dArduino. Enlever une bibliothque importe de l'IDE. .................................... P43
Library est un faux ami. La traduction franaise est Bibliothque Mthodes de la bibliothque arduino-pinchangeint.h. ...................... P44
et non pas Librairie comme trop souvent rencontr. Synthse d'utilisation des diverses bibliothques ......................... P44
SHIELD (Bouclier.) : Petite carte lectronique spcifique ddie
une application dont l'agencement permet le branchement
"gigogne" directement sur les connecteurs d'une carte Arduino.
Breakout board (Carte contrleur.) : Module circuit imprim,
souvent de trs petites dimensions, ddi gnralement un circuit
intgr spcialis complexe pour le rendre directement utilisable
dans l'environnement d'Arduino.
Dimanche, 10 Aril, 2016 Fichier LIBRARY.PM5
FE6AAE
 P2 P 43
Bibliothque Serial pour la communication srie. Dclarer les bibliothques utilises dans un programme.
La librairie Serial est utilise pour les communications par le port srie Deux syntaxes quivalentes sont possibles pour indiquer les dlimiteurs
entre la carte Arduino et un ordinateur ou d'autres composants. Toutes d'une bibliothque dont on veut utiliser les procdures :
les cartes Arduino ont au moins un port Srie qui communique sur les #include <Wire.h> #include "Wire.h"
broches 0 (RX) et 1 (TX) avec l'ordinateur via la ligne USB. Si cette #include <I2Cdev.h> OU #include "I2Cdev.h"
fonctionnalit est utilise dans le programme, les broches 0 et 1 en tant #include <MPU6050.h> #include "MPU6050.h"
qu'entres ou sorties numriques ne sont plus disponibles. Le terminal
srie intgr l'environnement Arduino, dont on peut dfinir le dbit, REMARQUE : Avec l'utilisation des dlimiteurs "<" les
communique directement avec une carte Arduino. Noter que la carte bibliothques par dfaut faisant partie de l'environnement d'Arduino
Arduino Mega , oute Serial sur 0 et 1 dispose de trois port srie passent en couleur marron dans l'diteur de l'IDE.
supplmentaires : Serial1 sur les broches 19 (RX) et 18 (TX), Serial2 Enlever une bibliothque importe de l'IDE.
sur les broches 17 (RX) et 16 (TX), Serial3 sur 15 (RX) et 14 (TX). Aller dans le dossier :
NOTE : Si une carte Arduino Mega est utilise, pour utiliser l'un des C:\Users\MICHEL\Documents\Arduino\libraries.
trois ports supplmentaires il suffit de faire suivre le mot clef Serial de On y trouve l'ensemble des bibliothques installes
1, 2 ou 3. Exemple : Serial1.begin(300); Serial2.begin(9600); par l'utilisateur.

Serial.begin(Dbit); . Y effacer les dossiers des

bibliothques que l'on
Fixe le dbit de communication en baud pour l'UART du P. Les 1

dbits standard sont respectivement 300, 1200, 2400, 4800, 9600,
14400, 19200, 28800, 38400, 57600, or 115200. On peut toutefois
spcifier d'autres dbits pour communiquer sur les broches 0 et 1 avec
un composant qui ncessite une vitesse particulire.
Serial.flush(); . l'IDE et en 2 les modules personnels qui ont t
Anciennement vidait le buffer de rception des donnes du port srie.
Actuellement c'est une fonction "inhibante" qui permet de s'assurer
que le tampon de transmission soit vide avant de repasser la main.
Serial.available();
Fonction qui retourne le nombre d'octets disponibles pour lecture
dans la file d'attente (Buffer) du port srie, ou 0 si elle est vide. Si une
donne est arrive, Serial.available() sera suprieur 0. La file
d'attente de la PILE FIFO peut contenir jusqu' 63 octets.
Serial.read();
Fonction de type int qui retourne le premier octet de donne entrant
disponible dans le buffer du port srie, ou -1 si aucune donne n'est
disponible. L'octet lu est enlev de la file d'attente qui est de type
FIFO. Le prochain appel Serial.read() lira l'octet suivant etc ...
Page 2
dsire supprimer.
Ouvrir un programme.ino quelconque, puis :
Croquis > Importer bibliothque... >
En 1 nous avons les bibliothques par dfaut de
ajouts. En 2 on ne doit plus trouver le nom des
bibliothques qui ont t supprimes. 2
Utiliser facilement une bibliothque.
.
Pour importer une bibliothque dans un programme, on peut
directement crire les lignes de dclaration indiques dans l'encadr
ci-dessus. Il est toutefois bien plus commode d'utiliser la suite de
commande liste ci-dessous :
Cliquer sur Croquis >
. Dplacer le curseur sur Importer bibliothque... >
BGS sur le nom de la bibliothque incorporer au programme.
Quelle que soit la position actuelle du curseur dans l'diteur, la
dclaration sera place en tte de programme, avec ventuellement
des bibliothques associes.
 P 42
IMPORTER UNE BIBLIOTHQUE :
L es bibliothques sont constitues d'une collection de code pour
faciliter l'interfaage d'un module ou d'un capteur spcifique
sur une carte ARDUINO. Il existe des centaines de bibliothques
supplmentaires disponibles gratuitement sur Internet en
tlchargement. Pour utiliser des bibliothques supplmentaires, il
faut les installer. Elles sont gnralement fournies sous la forme
d'un fichier ZIP ou d'un dossier. Le nom du dossier est le nom de
la bibliothque. Dans le dossier se trouve un fichier de type cpp,
un fichier de type h et souvent un fichier keywords.txt, un dossier
dexemples et ventuellement dautres fichiers requis par la
bibliothque.
1) Tlcharger la
bibliothque dans un
rpertoire quelconque,
2) Dcompacter le fichier 1 ;
ZIP dans ce rpertoire.
Page 3
La librairie est gnralement fournie sous
forme d'un dossier spcifique. Le nom de ce
dossier ne comporte que des lettres, des
chiffres, pas d'espace et ne doit pas
commencer par un chiffre. Le nom du dossier
2 Les caractres 'C' et les chanes "CCC" sont affichs directement.
est aussi celui des fichiers cpp et h.
3) Placer le dossier de la bibliothque
dcompress dans le rpertoire personnel
<C:\! ARDUINO\! Bibliothques importes>.
4) Ajouter la nouvelle bibliothque dans la liste disponible :
> > > tout en limitant le nombre de chiffres significatifs sept ou huit.
Indiquer le chemin du dossier personnel sur le H.D. (Prcis en
(2).) La bibliothque est alors ajoute dans le dossier personnel :
<C:\Users\MICHEL\Documents\Arduino\libraries>
ou ventuellement dans
<C:\Users\user\Documents\Arduino\libraries>.
5) Recharger un croquis quelconque. Cliquer sur puis placer
le curseur de la souris sur : En 1 on trouve
les bibliothques par dfaut et en 2 les bibliothques importes.
P3
Serial.end(); .
Dsactive la communication srie, ce qui permet de se servir des
broches RX et TX comme entres /sorties gnrales. Pour ractiver la
communication srie, il suffit de rutiliser Serial.begin(Dbit).
Serial.peek(); .
Fonction de type int qui retourne le premier octet de donne entrant
disponible sans l'extraire du FIFO de l'UART, ou -1 si aucune donne
n'est disponible. Des appels successifs peek() retournent le mme
caractre, tout comme le prochain appel la fonction read().
Serial.write(Donne); (Donne : Valeur ASCII ou Chane) .
crit les donnes binaires sur le port srie. Ces donnes sont envoyes
comme un octet ou une srie d'octets. Pour envoyer les caractres
d'une variable numrique utiliser la fonction Serial.print ().
>>> Pour les formats voir page 47 livret sur la SYNTAXE.
Serial.print(Donne,Format) .
Affiche les donnes sur le port srie sous une forme claire pour un
utilisateur Lambda. (Texte ASCII) Plusieurs formes sont possibles :
Les nombres entiers sont affichs de faon banale. .
Les nombres virgules float sont affichs de la mme manire avec
par dfaut deux dcimales aprs "la virgule". .
Les types byte sont affichs sous la forme d'un caractre ASCII.
>>> Pour les formats voir page 47 livret sur la SYNTAXE.
>>> Pour les caractres spciaux voir page 48 livret sur la SYNTAXE.
NOTE : Pour les formats d'un float, utiliser BIN, OCT, DEC ou HEX
va imposer un nombre de dcimales respectivement gal 2, 8, 10 et 16
La procdure ddie serialEvent().
Ce n'est qu'une petite subtilit : Si on donne une procdure
l'identificateur rserv "serialEvent()" cette dernire sera invoque
automatiquement en tout dbut de la boucle de base Loop sans avoir
insrer une instruction pour son appel. (Attention la casse.) Rien
n'interdit de donner notre routine un nom diffrent, et en faire l'appel
o bon nous semble dans code source du logiciel. Le petit programme
ESSAI_de_SERIAL-EVENT.ino propose un exemple d'utilisation.
 P4 P 41
Mthodes de la bibliothque Wire.h. (Complments en page 6) Le fichier KEYWORDS.txt
Cette librairie permet de communiquer avec des composants utilisant le
protocole I2C / TWI. (Communication srie sur 2 fils.)
Connexions. Sur la plupart des cartes Arduino :
S trictement optionnel, ce fichier permet l'IDE d'apprendre la
table des mots clef spcifiques la bibliothque pour activer
la coloration syntaxique. Quand les identificateurs sont spcifis
SDA (Ligne de donnes) est sur la broche analogique A4.
dans le fichier keyword.txt (Lettres majuscules ou minuscules.)
SCL (Signal d'horloge) est sur la broche analogique A5.
ces symboles seront alors affichs en couleur ocre dans l'diteur de
Sur Arduino Mega : SDA est sur Numrique 20 et SCLsur N21.
l'IDE comme pour tous les autres mots du langage. La syntaxe est :
Fonctions d'initialisation :
begin() initialise la communication avec un Arduino "matre". LCD_ST7565[TAB]KEYWORD1
begin(Adresse) initialise la liaison avec un Arduino "esclave". Envoyer_une_COMMANDE[TAB]KEYWORD2
Envoyer_une_DONNEE[TAB]KEYWORD2
Fonctions du "mode matre".
Contraste[TAB]KEYWORD2
requestFrom(Adresse, Quantit) : Demande de donnes un
Afficheur_en_veille[TAB]KEYWORD2
module esclave.
beginTransmission(Adresse) : Dbute la communication avec un Chaque ligne commence par le nom du mot-clef, suivi d'une
TABULATION, (Pas d'espaces, et UNE SEULE TABULATION.)
module esclave. (Ouvre le stockage de donnes envoyer avec write)
suivi par le type de mot-cl. KEYWORD1 prvu pour les classes
endTransmission() : Envoi des donnes vers l'esclave.
qui seront de couleur orange. KEYWORD2 pour les procdures et
write() : criture des donnes envoyer vers l'esclave.
les fonctions qui seront affiches en Ocre. (En version > 1.0 il
available() : Test si des donnes sont disponibles sur l'esclave.

Page 4
semble que 1 et 2 se traduisent tous les deux de la couleur ocre.) Il
read() : Lecture des donnes en provenance de l'esclave.
faut sortir puis redmarrer l'diteur Arduino pour que la table des
Fonctions du "mode esclave".
symboles soit prise en compte. Les lignes de commentaires doivent
write() : Envoie les donnes vers le matre aprs requte. commencer par le caractre # dans le fichier keyword.txt.
available() : Test si des donnes sont disponibles en provenance du
matre. (cf onReceive) Conventions sur les identificateurs : Les classes sont dsignes
read() : Lecture des donnes en provenance du matre. par des caractres majuscules. Les fonctions par des minuscules
onReceive(Fonction) : Dfinit la fonction appeler sur rception "titres" par des majuscules. Les constantes par conventions
de donnes en provenance du matre. d'criture seront avantageusement crites en majuscules.
onRequest(Fonction) : Dfinit la fonction appeler sur
requte du module matre. Choix du rpertoire pour dvelopper la bibliothque :
send() et receive() sont actuellement des fonctions obsoltes. Le plus simple consiste placer le dossier dans le rpertoire
MonPC\Documents\Arduino\Librairies\NomBibliotheque
Exemple d'utilisation : Les broches
#include <Wire.h> analogiques A4 et
void setup() { A5 sont imposes Le format pde pour les fichiers source.
... par l'usage de la Souvent, des exemples de programme Arduino sont donns au
Wire.begin(); bibliothque Wire.h format.pde qu'il faut transformer en textes compatibles avec
Le bus I2C est comment en dtails sur : Arduino. La mthode est simple. Il suffit de renommer le fichier
http://www.monnetamoi.net/articles.php?lng=fr&pg=352 pour remplacer le type pde par ino.
 P 40
Passage des paramtres utilisateur au constructeur.
B ien que les paramtres reprsentant les broches affectes aux
Entres/Sorties choisies par l'utilisateur de la bibliothque ne
vont pas changer, et sont gnralement des constantes, il faut
obligatoirement leur rserver des emplacements pour qu'elle
puissent exister dans le contexte. Dans le fichier d'entte :
private : byte RST, A0, SCLK, ... Retro_Vert, SID;
Il faut alors, dans le corps { ... } de PERSO_ST7565 tablir le lien
entre ces variables et les paramtres de l'instance logicielle :
RST=broche_RST;
A0=broche_A0;
SCLK=broche_SCLK;
Retro_Bleu=Retro_eclairage_Bleu;
Dans tout le code source on utilisera ensuite les identificateurs
des variables du genre A0 et non des paramtres tels que
broche_A0. La relation Paramtre/Variable tant tablie, on peut
coder le programme source avec la syntaxe habituelle :
Page 5
pinMode(SCLK, OUTPUT); digitalWrite(SCLK, LOW);
Rsum de l'architecture de base du fichier.ccp
#include "PERSO_ST7565.h" // Par filiation "rcupre" les #includes de l'entte.
#define Contraste_Dynamique B10000001
#define LED_Arduino 13
PERSO_ST7565::PERSO_ST7565(byte broche_RST, ... ) {
RST=broche_RST;
Initialisations et
A0=broche_A0;
configurations de
SCLK=broche_SCLK;
la classe.
...
pinMode(Retro_Bleu, OUTPUT);
pinMode(SCLK, OUTPUT); digitalWrite(SCLK, LOW);
Envoyer_une_COMMANDE(B10100010);
...
Afficheur_en_service(); Effacer_Ecran(); Surbrillance(0); }
Puis suivent les diverses fonctions et procdures :
void PERSO_ST7565::Envoyer_une_COMMANDE(byte OCTET)
{ ... traitement relatif la procdure ...}
... / ...
P5
Complments relatifs la bibliothque Wire.h.
Cette librairie est documente en page 4.
Il existe plusieurs volutions de la norme qui permettent de communiquer
des dbits toujours plus importants :
Standard mode : 100 kbit/s, Fast mode : 400 kbit/s,
Fast plus mode : 1 Mbit/s, High-speed mode : 3,4 Mbit/s,
Ultra-fast mode : 5 Mbit/s
Pour nos ralisations nous allons surtout utiliser le Standard mode et
ventuellement le "Fast mode". Pour Arduino, la bibliothque Wire.h
est par dfaut configure pour des changes en Standard mode.
Les quipements connects au bus dialoguent suivant un mcanisme
matre/esclave. Un quipement esclave ne rpond qu des demandes
en provenance dun matre. Il peut y avoir N matres et N esclaves sur
un bus commun. Attention cependant, en cas dutilisation de plusieurs
matres, ces derniers doivent tre capables de dtecter quun autre matre
utilise dj le bus avant dmettre. Un quipement ne peut pas tre la
fois matre et esclave nanmoins il peut changer de rle au cours du
temps. (Passer de matre esclave et inversement)
Toutes les spcifications du bus I2C sont dcrites sans le document :
http://www.diolan.com/downloads/i2c-specification-version-4.0.pdf
Mthodes de la bibliothque EEPROM.h. (Voir @)
L'EEPROM est une mmoire non-volatile (Un kilo-octet sur
l'ATmega328 : $0000 $0400) mise la disposition du programmeur
pour y stocker des donnes "constantes" destines au long-terme.
Utilisation de la bibliothque EEPROM.h.
Suite la dclaration #include <EEPROM.h> on peut utiliser :
Octet = EEPROM.read(ADR); .
Fonction qui lit la valeur contenue dans la cellule d'EEPROM
l'adresse ADR prsente dans le l'EEPROM d'Arduino. Pour le premier
octet ADR = $0000. Les emplacements qui n'ont jamais t crit
contiennent $FF. Elle retourne une donne de type byte.
EEPROM.write(ADR,OCTET); .
Procdure qui crit le contenu du byte OCTET l'emplacement
EEPROM point par ADR. (Type int) L'EEPROM est limite environ
100 000 cycles d'criture. Donc ne pas l'utiliser comme une RAM.
@ : Prfrer la bibliothque avr/eeprom.h dcrite en page 32 optimise en
taille, en rapidit et qui permet de manipuler des donnes de tailles variables.
 P6
La bibliothque I2Cdev.h.
F ondamentalement, la Bibliothque de priphriques I2C est une
collection de classes homognes pour fournir des interfaces
simples et intuitives une varit toujours croissante de dispositifs I2C.
Chaque appareil est conu pour utiliser le code gnrique d'I2Cdev.h,
qui permet de faire abstraction de la communication I2C au niveau du
bit et au niveau de l'octet. Non spcifique une classe d'appareil
particulire, le code propre un systme est plus facile "transporter"
sur diffrentes plates-formes.
Le code relatif I2Cdev.h est programm pour tre utilis de manire
statique, ce qui rduit les besoins en mmoire si vous avez plusieurs
priphriques I2C inclus dans le projet en cours de dveloppement. Une
seule instance de la classe I2Cdev est ncessaire.
C ette bibliothque I2Cdev.h n'est pas autonome, elle fait appel
Wire.h et doit tre complte par une bibliothque spcifique
au composant en communication I2C avec le programme en cours de
dveloppement. La logique d'un programme utilisant ces trois
Page 6
bibliothques adopte une structure du type :
// Librairie requise pour communiquer avec des modules sur l'interface I2C.
#include "Wire.h" // (Bibliothque installe par dfaut sur Arduino.)
// Inclusion d'une bibliothque permettant de communiquer avec un
// module particulier communiquant travers I2C.
#include "I2Cdev.h"
// Inclusion d'une bibliothque intgrant de nombreuses fonctions
// permettant d'accder aux informations issues du module connect :
// Dans ce programme un capteur acclromtrique et gyroscopique 3
// axes MPU6050. // (Librairy intgre dans le "paquet MPU6050.h")
#include "MPU6050_6Axis_MotionApps20.h"
Puis suivent les dclarations propres au capteur, les initialisations et
enfin les procdures et fonctions du programme.
Voici les structures de donnes pour I2Cdev.h avec une description
disponible sur : http://www.i2cdevlib.com/docs/html/index.html
Tlchargeable sur http://www.3sigma.fr/telechargements/I2Cdev.zip
P 39
Le fichier du code source.ccp
C ommenant comme le fichier d'entte par des directives pour
le prprocesseur, il contiendra l'ensemble du code
d'implmentation qui conduit aux mthodes excutables et
commence normalement par #include "PERSO_ST7565.h" et en
hrite des directives #include qui s'y trouvent. Par exemple du
#include <Arduino.h> qu'il serait nfaste de ritrer provoquant
des dfinitions multiples. Ensuite, on peut ventuellement trouver
des directives #define qui permettent de dfinir des constantes.
#define Allume_Tout B10100101 // Allume tous les points.
On doit obligatoirement trouver la dclaration de la classe avant
l'criture des mthodes. L'architecture ressemble :
PERSO_ST7565::PERSO_ST7565(Les paramtres) {
...
Dclarations et instructions
... }
La premire occurrence de PERSO_ST7565 dfinit un type classe
et Les paramtres sont strictement identiques en type, ordre et
identificateurs ceux de la dclaration de la classe dans public :
PERSO_ST7565(byte broche_RST, ... byte broche_SID);
du fichier d'entte. Ensuite, entre les dlimiteurs { et } on trouvera
tout ce que le compilateur devra faire quand dans le programme
utilisateur il y aura appel au constructeur de PERSO_ST7565 :
Gnralement, quand on cre la classe, on doit configurer les
Entres/Sorties, les initialiser, envoyer des consignes au
priphrique pilot pour une initialisation de base etc.
L'oprateur de rsolution de porte :: (Appel aussi double
deux points.) pour simplifier, est utilis pour rfrencer des
lments appartenant une classe et non un objet quelconque.
La deuxime occurrence de PERSO_ST7565 dfinit le constructeur
PERSO_ST7565 qui par l'entremise de :: appartient cette classe.
Les procdures et fonctions qui suivent commencent naturellement
par void, mais il faut tablir leur appartenance la classe. La
description d'une mthode doit donc respecter l'criture :
void PERSO_ST7565::MAJ_PTR(Paramtres) { Code source }
... / ...
P 38
Toutes les dclarations relatives la classe concerne seront
regroupes entre les dlimiteurs { } suivis en d'un point-virgule.
Enfin en le fichier d'entte termine par la directive #endif.
Le corps des directives peut comporter d'autres dclarations comme
les constantes et les variables utilises dans la bibliothque.
Dans private : Variables dclares en gnral en
boolean Surbrillance; private pour les protger des
"contaminations" externes.
byte OCTET, BIT, PAGE;
byte MEMOIRE[1024]; // Ici on dclare un grand tableau.
Entres/Sorties dfinies par l'utilisateur.
L aisser l'utilisateur la possibilit de rpartir sa guise les
broches de l'ATmega328 qui seront utilises pour piloter son
afficheur est un incontournable. Dans ce but, on doit dclarer dans
le fichier d'entte une instance logicielle de l'objet afficheur :
Dans public :
PERSO_ST7565(byte broche_RST, ... byte broche_SID);
Une telle dclaration commence par le nom de l'objet qui est
Page 7
identique celui de la bibliothque, suivi entre parenthses de la
liste des identificateurs pour les broches qui seront utilises. Comme
il s'agit d'un "passage de paramtre", les valeurs sont types.
NOTE : Plus gnralement, l'utilisateur de la bibliothque passera
en paramtres diverses constantes, et pas forcment le numro des
broches utilises par la classe dcrite dans le constructeur.
Protger ou accder une variable dans une classe.
D' une faon gnrale il est fortement recommand de dclarer
en private : les variables d'une classe pour les protger.
La visibilit de ces dernires sera alors limit au "domaine" de la
classe instancie. Le mot clef public : prcise que les lments
dont la liste fait suite sont accessibles par toutes les fonctions et
procdures y compris depuis le programme.ino qui inclus la classe.
Naturellement les mthodes "utilisateur" seront publiques.
On peut si on dsire pouvoir les modifier dclarer des entits dans
le domaine public : leur utilisation imposant de faire rfrence
la classe pour leur affecter ou y lire des valeurs. Exemple :
Dans le fichier.h on crit : public : byte TEST;
Et pour utiliser dans le croquis.ino : LCD.TEST = TEST + 25;
... / ...
P7
Mthodes de la bibliothque LedControl.h.
Cette librairie facilite grandement la gestion par la SPI spcifique d'un
multiplexeur spcialis pour les afficheurs 7 segments ou les matrices
de LED et ncessite un circuit intgr MAX7219 ou MAX7221.
Initialisations diverses.
LedControl Mon_afficheur = LedControl(Din,CLK,LOAD,Nb);
Cre une instance de ledcontrol en utilisant un identificateur associ.
Les trois broches qui gnrent les signaux vers la ligne SPI du (des)
MAX7219 sont listes dans l'ordre. Le nombre de modulesNb chans
avec Dout sur la SPI termine la liste des paramtres. Si plusieurs
multiplexeurs sont utiliss, il est plus logique de les chaner par la SPI
et utiliser un seul objet ledcontrol pour tous les contrler.
Mon_afficheur.shutdown(Num,tat);
Par dfaut, la mise sous tension le MAX7219 est en mode veille.
.
Cette instruction permet de le rveiller avec false ou de le rendormir
avec true. Num dsigne le module concern dans le chanage ventuel,
le premier tant le 0. Chaque circuit doit tre command sparment.
Mon_afficheur.setIntensity(Num,Clart); .
Ajuste l'intensit lumineuse de chaque module. Clart : De 0 15.
Mon_afficheur.clearDisplay(Num); .
Efface (teint) l'intgralit de l'afficheur pilot.
Mon_afficheur.setScanLimit(Num,Limite); Par dfaut le balayage
se fait sur les huit "DIGIT". Mais si la luminorit est trop faible, on
peut restreindre le balayage aux seuls afficheurs effectifs. Attention :
Risque de destruction du MAX7219 par surintensit ! (Voir notice)
Modes d'affichage sur 7 segments ou sur Matrice de LED.
Mon_afficheur.setDigit(Num,Position,Chiffre,Dp); .
S'utilise implicitement avec des afficheurs 7 segments sur lesquels on
dsire visualiser des chiffres. Le paramtre Dp qui vaudra true ou
false allumera ou teindra le point dcimal du "DIGIT" associ. La
valeur de Position est comprise entre zro et sept.
Mon_afficheur.setLed(Num,Ligne,Colonne,tat); .
Instruction spcifique la mise en uvre de matrices de LED. Elle
permet d'allumer ou d'teindre une LED individuelle de l'afficheur en
spcifiant ses coordonnes. Les valeurs de Ligne et de Colonne vont
de 0 7. tat conditionne la LED avec true ou false.
Mon_afficheur.setRow(Num,Range,Octet); .
Instruction qui place directement les tats prciss par Octet dans
l'alignement Range (Entre 0 et 7) de l'objet ledcontrol Num.
 P8 P 37
La bibliothque SD.h. CRER UNE BIBLIOTHQUE PERSONNELLE :
D rive de la bibliothque sdfatlib.h de William Greiman qui
propose davantage de fonctions, la bibliothque SD.h est
fournie en standard dans l'environnement IDE et s'avre dj
P rservs dans un dossier commun, les bibliothques Arduino
sont composes d'au moins deux fichiers : Un fichier d'en tte
(Le header.) d'attribut .h et un fichier de code source ayant pour
largement suffisante pour couvrir des attribut .cpp les deux ayant le mme nom identique celui du dossier
applications trs toffes. Le tableau qui hberge les modules. (.c en langage C standard et .cpp en
ci-dessous prcise les branchements version C++.) Le fichier d'en tte contient la liste des fonctions
vers ARDUINO imposs par la disponibles et le fichier source contient l'implmentation du code.
bibliothque, qui librent les deux la compilation la totalit du code sera analyse.
lignes TX et RX ainsi qu'un maximum de sorties de type PWM.
Le fichier d'entte.h (h comme Head)
CS Slection de la carte 10
DI
VSS
Entre srie SPI. (MOSI)
Masse. (GND)
11
GND
F ondamental, il sert dclarer l'intgralit des modules qui
seront impratif son bon fonctionnement : Les procdures
et les fonctions, les variables sans oublier la gestion des #include
VDD + Alimentation. (+3.3) Non branch ncessaires cette bibliothque. Pour que cette dernire puisse
CLK Horloge de la SPI. (SCK) 13
utiliser des fonctions propres Arduino il faut une dclaration
DO Donnes sries de la SPI. (MISO) 12 #include <Arduino.h> (Version > 1.00) qui fait partie du "core
La librairie SD.h permet de lire et d'crire sur des cartes mmoires Arduino" et n'a pas tre tlcharge sur Internet. On peut galement

Page 8
SD et SDHC. Supportant les systmes de fichier FAT16 et FAT 32
sur les cartes mmoires SD standard et les cartes SDHC. L'ouverture
simultanne de plusieurs fichiers est possible. Les noms de fichiers
doivent respecter le format 8.3 au standard assez ancien. Les noms
de fichiers peuvent inclure des chemins spars par des slash "/", le
rpertoire de travail tant toujours la racine de la carte SD, un nom
se rfre au mme fichier, qu'il inclue ou non un slash. (Exemple :"/
Mon_Fichier.txt" est quivalent "Mon_Fichier.txt".)
Cette librairie ouvre des possibilits de stockage de donnes
considrables puisque les cartes SD disposent facilement de 8Go
16Go d'espace. Elles peuvent tre lues directement sur un PC. En
enregistrant les donnes dans un fichier texte au format CSV, on
rend possible un traitement des donnes enregistres directement
dans un tableur par exemple, avec ralisation de graphiques, etc...
Outre la directive incontournable #include <SD.h> on doit
galement complter avec appel une bibliothque de gestion des
protocoles de communication Arduino sur la ligne de dialogue I2C. Par
exemple on ajoutera un #include <SPI.h> en tte de programme.
inclure des modules qui sont spcifiques la bibliothque et situs
dans son dossier. Dans ce cas les dlimiteurs sont des guillements.
Par exemple #include "Ma_police_de_caracteres".
Le fichier d'entte comprendra au minimum :
#ifndef PERSO_ST7565_h // Si non dj dfinie. (1)
#define PERSO_ST7565_h // On la dfini.
#include <Arduino.h> // probablement indispensable.
class PERSO_ST7565 {
public :
void Envoyer_une_COMMANDE(byte OCTET);
};
(1) Attention : "_" et non le "." pour dsigner l'identificateur.
#endif
Avant tout contenu, il faut en et viter que le fichier d'en tte
ne soit victime d'inclusions multiples. Donc on ajoute une protection
avec des directives de prprocesseur. Il est probable que l'on utilisera
des procdures de l'IDE ce qui impose la dclaration . Comme pour
une variable quelconque, il faut dclarer un objet : En on dfinit
la classe avec le mme nom que celui de la bibliothque. En
publicon va dclarer en au moins une mthode.
... / ...
P 36
Traitement des chanes de caractres.
Impose pour la dclaration des chanes la syntaxe avec le "=" :
PROGMEM const char Bonjour[] = "Bonjour ";
const char Les_Amis[] PROGMEM = "les Amis.";
L'utilisation des constantes chane oblige crire une procdure
spcifique avec pour paramtre un pointeur :
void Affiche_TEXTES_en_FLASH(char *PTR) {
char I=0; char CarASCII=1; // Dif de 0 pour entrer en boucle.
while(CarASCII != '\0') { // Tant que non fin de chane :
CarASCII = pgm_read_byte(PTR + I);
if (CarASCII != 0) Serial.print(CarASCII); I++; } }
Traitement des tables d'OCTETs.
Bien que PROGMEM fonctionne avec des variables lmentaires,
il est plus judicieux de s'en servir avec des blocs de donnes
stocker, comme des tableaux ou d'autres structures de donnes en
langage C. L'exemple typique est celui d'un dessin de type LOGO,
d'une table pour gnrer des caractres en matrice 5 x 7 etc.
Page 9
Exemple de dclaration pour des OCTETs :
PROGMEM const byte TABLE_ASCII[] =
{B00000000, B00000000, B00000000, B00000000, B00000000, // ESPACE
B00000000, B00000000, B01001111, B00000000, B00000000, // !
B00000000, B00000011, B00000000, B00000011, B00000000, // "
... ... ... ... ... ... ... ... ... ... ... ...
B00011100, B10100000, B10100000, B10100000, B01111100, // y
B01000100, B01100100, B01010100, B01001100, B01000100, // z
... ... ... ... ... ... ... ... ... ... ... ...
B00000000, B01000001, B00110110, B00001000, B00000000, // }
B00001000, B00001000, B00101010, B00011100, B00001000, // Flche D
B00001000, B00011100, B00101010, B00001000, B00001000 }; // Flche G
Exemple de lecture des OCTETs :
Impose d'crire une procdure pour "balayer" la matrice de caractre.
void Affiche_Caractere(byte ASCII) {
int PTR = ASCII * 5;
for(byte Colonne=0; Colonne<5; Colonne++)
{ Aff_Colonne (pgm_read_byte(&TABLE_ASCII[PTR]));
PTR++;} Aff_Colonne(0); }
... / ...
P9
Mthodes de la classe SD.
Sd2Card Carte_SSD ; Procdure qui instancie la classe SD.
Sd2Volume Contenu ; Identifie la "directory".
Sd2Card Racine ; Identifie la racine de la "directory".
const byte ChipSelect = 10; Dclaration de l'identificateur utilis.
Carte_SSD.init(Rapidit,ChipSelect); .
Fonction qui prcise par les identificateurs rservs la vitesse de
communication sur la SPI. Rapidit peut prendre les valeurs : .
SPI_FULL_SPEED : Frquence CLK = Frquence CPU / 2.
SPI_HALF_SPEED : Frquence CLK = Frquence CPU / 4.
QUARTER_SPEED : Frquence CLK = Frquence CPU / 8.
Retourne true si l'initialisation a russie, false si non ralise.
SD. b e g i n ( ChipSelect) .
Fonction boolenne qui initialise la librairie SD et la carte SD et
active l'utilisation du bus SPI (Sorties binaires 11,12 et 13) et
initialise la broche ChipSelect qui par dfaut est la broche
matrielle SS. (Broche 10 sur la plupart des cartes Arduino.)
Mme si une broche de slection diffrente est utilise, la broche
matrielle SS doit tre laisse en SORTIE, sinon les mthodes de
la librairie SD ne fonctionneront pas correctement. Le paramtre
ChipSelect est optionnel si l'on conserve la broche 10 par dfaut.
L a f o n c t i o n r e t o u r n e t r u e si russite et f a l s e s i c h e c .
Exemple d'utilisation :
if (!SD.begin(ChipSelect))
{ Serial.println("Echec de l'initialisation."); return; }
Serial.println("Initialisation OK.");
SD. m k d i r ( " D O S S I E R / P r o v ") .
Fonction qui cre un rpertoire sur la carte mmoire SD ainsi que les
rpertoires intermdiaires qui n'existent pas encore. Retourne true si
la cration du chemin a russi, et false s'il y a chec.
SD. r m d i r ( " D O S S I E R " ) .
Fonction boolenne qui efface tout un rpertoire, incluant les
sous-rpertoires dlimits par des slashs "/". Le rpertoire doit
tre vide. Retourne true si le rpertoire a bien t effac, et false
s'il n'a pas pu tre effac. La valeur renvoye n'est pas spcifie si le
rpertoire n'existe pas.
... / ...
P 10
File Mon_Fichier;
Le constructeur File permet de dclarer un objet de type File pour la
librairie SD, objet qui reprsente un fichier. Un tel objet pourra recevoir
notamment l'objet File renvoy par la fonction SD.open().
Mon_Fichier = SD.open("ESSAI.TXT", Option)
Fonction boolenne qui ouvre un fichier sur la carte mmoire SD.
Si le fichier est ouvert pour criture, il sera cr s'il n'existe pas
dj. (Le chemin de destination doit cependant exister.)
Plusieurs fichiers peuvent tre ouvert : Voir note en bas de page.
Les noms de fichiers prsenteront huit lettres au maximum, et
ventuellement un point suivi au maximum de trois lettres. Le
mode par dfaut est FILE_READ qui ouvre le fichier en
positionnant le pointeur au dbut. FILE_WRITE ouvre le fichier
en lecture et criture, en dmarrant au dbut du fichier. La fonction
retourne true si l'ouverture a russie, et false dans le cas contraire.
Mon_Fichier peut donc tre test comme un boolen classique.
SD. e x i s t s ( " E S S A I . T X T ")
Fonction boolenne qui teste la prsence d'un rpertoire (Dlimit par
des slash "/".) ou d'un fichier dont on passe en paramtre le nom.
SD. r e m o v e ( " D O S S I E R / A v i d e r . t x t " )
Fonction boolenne qui efface un fichier de la carte mmoire.
Retourne true si le fichier a t effac, et false s'il n'a pas pu tre
effac. La valeur renvoye n'est pas spcifie si le fichier n'existe pas.
Le nom du fichier peut inclure un chemin dlimit par des slashs.
Mthodes de la classe FILE.
Mon_Fichier.available()
Fonction boolenne qui vrifie si des octets sont disponibles en
lecture dans le fichier. Retourne le nombre d'octets disponibles
ou zro si le fichier est vide ou ferm.
Mon_Fichier.close();
Cette procdure ferme le fichier, et s'assure que toute donne crite
dans ce fichier est physiquement enregistre sur la carte mmoire
SD. Comme la librairie SD.h ne peut ouvrir qu'un seul fichier
la fois, il faut fermer un fichier avant d'en ouvrir un autre.
NOTE : Bien que non signal sur les documentations mises en ligne,
il semble parfaitement possible de travailler simultanment sur deux
... / ...
P 35
. Les types de donnes utilisables.
L'utilisation de certains types de donnes peuvent conduire des erreurs
nigmatiques. (Les float ne sont pas correctement traits.) Il importe
donc de n'utiliser que les types de donnes dclars dans la bibliothque
. avr/pgmspace.h soit char, int et long. (signed ou unsigned)
Quelques exemples de dclaration :
PROGMEM const char CaractereA ('A');
. const unsigned char Car_F PROGMEM ('f');
const byte Vingt PROGMEM = 20;
PROGMEM const int Moins32000 (-32000);
PROGMEM const unsigned int Plus65000 (+65000);
PROGMEM const long Moins12345678 = -12345678;
PROGMEM const unsigned long Plus4Giga = +4000000000;
Dans ces exemples les deux positions de PROGMEM dans la
dclaration sont utilises. Pour affecter une valeur la constante,
on peut utiliser deux critures quivalentes : Soit on fait suivre la
dclaration par le "=" de faon classique, soit on indique la constante
. entre parenthses. L'indication const avant le type est obligatoire.
Page 10
Noter que dclarer un caractre ASCII en unsigned char il devient
un nombre, une instruction comme Serial.print affichera son code.
.
Utilisation des donnes places en mmoire programme.
Intimement lie la notion de pointeur et de passage de paramtre par
adresse, l'utilisation des constantes loges en mmoire FLASH en
reprend plus ou moins directement la syntaxe d'criture. Dans les
exemples qui suivent, les mthodes spcifiques avr/pgmspace.h sont
colories en rose et sont associes au type dclar pour la variable :
. Serial.println(CaractereA);
Serial.println(Car_F); // Affiche 102 le code ASCII de 'f'.
Serial.println(Vingt);
int ENTIER;
. ENTIER = pgm_read_word(&Moins32000);
unsigned int EntierPositif;
EntierPositif = pgm_read_word(&Plus65000);
long DoubleOctet;
DoubleOctet = pgm_read_dword(&Moins12345678);
unsigned long DoubleOctetPositif;
DoubleOctetPositif = pgm_read_dword(&Plus4Giga);
... / ...
P 34
Mthodes de la bibliothque avr/pgmspace.h.
Cette librairie est prvue pour loger en mmoire de programme des
constantes dans le but de librer de la place dans la SRAM. La mmoire
Flash dite "de programme" est ddie au stockage du code objet
compil envoy au microcontrleur au moment du "tlversement".
Comme toutes les mmoires Flash, sa dure de vie se situe environ
100000 critures et effacements. LIDE en fait donc un usage particulier
: On ne peut y enregistrer des donnes quau moment du
"tlversement" du programme. Elle fonctionne ensuite en lecture
seule, donc on ne peut que lire des donnes et plus les modifier.
Utilisation de la mmoire FLASH pour loger des donnes.
Au mme titre que l'EEPROM, la mmoire FLASH prvue pour loger
le programme peut galement tre utilise pour y loger des donnes.
D'un accs aussi rapide que celui de la RAM, elle conserve les donnes
sur coupure d'alimentation. La mmoire FLASH doit tre considre
comme une mmoire accessible uniquement en lecture de constantes.
Par prcaution le programme doit commencer par la directive
P 11
ou plusieurs fichiers. Il suffit d'utiliser plusieurs fois le constructeur
File avec des identificateurs diffrents.
M o n _ F i c h i e r. f l u s h(); .
Cette procdure s'assure que les donnes crites dans un fichier
ont t physiquement enregistres sur la carte mmoire SD. Ceci
est fait automatiquement galement lorsque le fichier est ferm
avec la fonction close();
M o n _ F i c h i e r. r e a d ( ) ; .
Fonction qui lit un octet dans un fichier et retourne sa valeur sous
forme d'un byte. Positionne le pointeur sur le prochain octet du
fichier. Retourne -1 si octet indisponible.
M o n _ F i c h i e r. p e e k( ) ; .
Fonction qui lit un octet dans un fichier et retourne sa valeur sous
forme d'un byte. N'avance pas le pointeur sur le prochain octet du
fichier. Retourne -1 si octet indisponible. (Plusieurs appels
successifs fonction peek(); renverront la mme valeur.)

classique #include <avr/pgmspace.h> sachant qu'avec les
versions actuelle de l'IDE ce n'est pas un impratif.
PROGMEM const type NomConstante (Valeur);
PROGMEM est un modificateur de variable, et ne peut s'utiliser
qu'avec les types restrictifs de donnes dfinis dans la librairie
avr/pgmspace.h qui impose au compilateur de placer les donnes
dans la mmoire FLASH", au lieu de la SRAM, o elles devraient
rsider en standard. (Voir types de donnes page suivante.)
La directive PROGMEM tant un modificateur de variable, donc
en principe il n'y a pas d'emplacement obligatoire, et le compilateur
d'Arduino devrait accepter toutes les dfinitions quivalentes.
L'exprience montre que dans certaines versions anciennes il y a
disfonctionnement si le mot clef PROGMEM est positionn aprs
le type et avant le nom de la variable :
Type NomConstante[] PROGMEM = {}; // Accept.
PROGMEM Type NomConstante[] = {}; // Accept.
Type PROGMEM NomConstante[] = {}; // Ne pas utiliser.
Page 11
M o n _ F i c h i e r. s i z e ( ) ; .
Fonction qui retourne la valeur de la taille du fichier en nombre
. d'octets sous forme d'un long. Le fichier doit tre ouvert au moment
o la fonction size() est invoque.
Mon_Fichier.position(); .
Fonction qui retourne la valeur du pointeur de position dans le
fichier sous forme d'un long. (Correspond la position o le
prochain octet sera lu ou crit.)
M o n _ F i c h i e r. s e e k( ) ; .
Cette fonction permet de placer le pointeur de lecture/criture
une nouvelle position, qui doit tre comprise entre 0 et la taille du
fichier. (Taille dclare inclusive.) Retourne true si russite et
false s'il y a chec. Le fichier doit tre ouvert.
NOTE : Pour effacer entirement le contenu d'un fichier, il
suffit de l'effacer avec l'instruction SD.remove puis de le
recrer avec SD.open.
... / ...
P 12
Mon_Fichier.write(Data);
Mon_Fichier.write(Tableau, Nb);
Procdure prvue pour crire des donnes Data dans un fichier
pralablement ouvert. Data peut tre un byte, un char ou une
"Chaine de caracteres". Exemples :
const byte Octet = 65; // 'A' en ASCII.
char TABLEAU[5] {'5','4','3','2','1'};
Mon_Fichier.write(Octet);
Mon_Fichier.write('B');
Mon_Fichier.write("Texte");
Mon_Fichier.write(TABLEAU, 3);
Mon_Fichier.write(TABLEAU, 2);
La directive on cre une donne de type byte. En on cre un
tableau de cinq caractres ASCII. En on crit la valeur d'Octet
dans le fichier. Puis en on y ajoute le caractre 'B' suivi en
d'une chane de caractres. En on copie les 3 premiers lments
du tableau. Comme cette syntaxe lit toujours partir du dbut du
tableau, en on rcrit les 2 premiers lments. Chaque criture
dans Mon_Fichier incrmente le pointeur de Lecture/criture.
Mon_Fichier.print(Data);
Mon_Fichier.print(Data, BASE);
Procdure pour pour crire des donnes Data dans un fichier
pralablement ouvert. Data peut tre un byte, un char, un int, un
long, un float ou une "Chaine de caracteres". Les nombres sont
crits comme des squences de chiffres textuels ASCII. L'option
BASE spcifie ventuellement la base dans laquelle est
transforme le nombre : BIN, (Base 2) DEC, (Base 10 par dfaut)
OCT, (Base 8) et HEX. (hexadcimal)
Mon_Fichier.println();
Mon_Fichier.println(Data);
Mon_Fichier.println(Data, BASE);
Procdure totalement analogue Mon_Fichier.print(Data), qui
crit des donnes Data dans un fichier pralablement ouvert et
qui ajoure deux octets la suite : "Retour chariot" + "passage la
ligne". Les formats d'criture sont strictement identiques.
... / ...
P 33
Fonction Lire un float
. . int Lire_un_Float_en_EEPROM(int ADRESSE) .
{return eeprom_read_float((float *) ADRESSE);}
Exemple: REEL = Lire_un_Float_en_EEPROM(PTR_EEPROM);
Procdure crire un float
void Ecrire_un_Float_en_EEPROM(int ADRESSE, Float REEL)
{eeprom_write_float((float *) ADRESSE, REEL);}
Exemple d'appel : Ecrire_un_Float_en_EEPROM(PTR,REEL);
crire ou lire un BIT individuel en EEPROM :
Ces mthodes ne sont pas prvues dans les routines proposes en
standard par la bibliothque avr/eeprom.h mais elles ne sont pas
spcialement compliques coder :
Fonction Lire un BIT individuel
boolean Lire_un_BIT_en_EEPROM(int ADR, byte N) {
return ((eeprom_read_byte((unsigned char *) ADR)) >> N) & 1;}
Page 12
L'ordre du BIT N doit tre compris entre [0 et 7].
Exemple d'utilisation :
boolean BIT; BIT = 3; PTR = 1020;
BIT = Lire_un_BIT_en_EEPROM(PTR, BIT );
. .
Procdure crire un BIT individuel
void Ecrire_un_BIT_en_EEPROM(int ADR, byte N, boolean Etat)
{ byte Octet, Masque;
Octet = eeprom_read_byte((unsigned char *) ADR);
Masque = 1 << N;
if (Etat) Octet = Octet | Masque;
else {Masque=~Masque; Octet = Octet & Masque;}
eeprom_write_byte((unsigned char *) ADR, Octet);}
L'ordre du BIT N doit tre compris entre [0 et 7].
L'tat du BIT peut tre true, false, "1" ou "0".
.. Exemple d'utilisation :
Ecrire_un_BIT_en_EEPROM(844, 7, 0);
// L'emplacement relatif n844 verra son BIT n7 forc zro.
http://www.nongnu.org/avr-libc/user-manual/
group__avr__eeprom.html#ga2d4ee8b92a592c764785fb5e4af5662b
P 32
Mthodes de la bibliothque avr/eeprom.h.
Cette bibliothque remplace avantageusement EEPROM.h dcrite en
bas de la page 5. Il n'y a pas besoin de la dclarer avec un include ce
qui rsous pas mal de problme dans la rdaction de bibliothques
personnelles. Le code gnr est plus compact et fonctionne plus
rapidement. On peut lire et crire des entits de tailles diffrentes.
Utilisation de la bibliothque :
Il suffit dans le programme utilisateur d'ajouter les procdures et
les fonctions dont on a besoin puis d'y faire appel. Dans les exemples
qui suivent les identificateurs coloris en rose sont ceux de la
bibliothque avr/eeprom.h et il ne faut pas les modifier.
Fonction Lire un octet
byte Lire_Octet_EEPROM(int ADRESSE)
{return eeprom_read_byte((unsigned char *) ADRESSE);}
. I
Exemple d'appel : OCTET = Lire_Octet_EEPROM(PTR_EPROM);
Procdure crire un octet
void Ecrire_Octet_EEPROM(int ADRESSE, byte OCTET) . if (!Carte_SSD.init(SPI_HALF_SPEED, ChipSelect)))
Page 13
{eeprom_write_byte((unsigned char *) ADRESSE, OCTET);}
Exemple d'appel : Ecrire_Octet_EEPROM(PTR,Donne);
Fonction Lire un entier
int Lire_Entier_EEPROM(int ADRESSE) .
{return eeprom_read_word((unsigned int *) ADRESSE);}
Exemple d'appel : Entier = Lire_Entier_EEPROM(PTR_EPROM);
Procdure crire un entier
void Ecrire_Entier_EEPROM(int ADRESSE, int OCTET) . Racine.openRoot(&Contenu);
{eeprom_write_word((unsigned int *) ADRESSE, OCTET);}
Exemple d'appel : Ecrire_Entier_EEPROM(PTR,Donne);
Fonction Lire un long
int Lire_un_Long_en_EEPROM(int ADRESSE) . par le return, tout ce qui suit sera ignor. En les paramtres sont
{return eeprom_read_dword((unsigned long *) ADRESSE);}
Exemple: Quatre_Octets = Lire_un_Long_en_EEPROM(PTR);
Procdure crire un long
void Ecrire_un_Long_en_EEPROM(int ADRESSE, long QtrOct)
{eeprom_write_dword((unsigned long *) ADRESSE, QtrOct);}
Exemple d'appel : Ecrire_un_Long_en_EEPROM(PTR,Donne);
P 13
Afficher le contenu d'un fichier.
F aire afficher le contenu d'un fichier n'est pas prvu, car la
prsentation sera fonction de la nature des donnes qui y sont
contenues. L'criture d'une procdure ddie est assez simple :
// On ouvre le fichier, ou on repositionne le pointeur au dbut :
Mon_Fichier.seek(0); // 0 ou plus pour commencer plus loin.
while (Mon_Fichier.available()
{ Serial .write(Mon_Fichier.read()); };
Il faut galement vrifier l'existence du fichier. (Voir ci-dessous.)
Afficher le contenu de la carte mmoire.
ssue de la bibliothque sdfatlib.h de William Greiman
l'exemple de programme qui suit en utilise certaines
fonctionnalits facilitant le traitement de la "directory" et, en
particulier, permet l'exploration des sous-dossiers.
// Vrification de la prsence carte :
{Serial.println("Pas de carte SD."); return;}
else {Serial.println("Carte presente dans le lecteur.");
// Vrification des donnes :
if (!Contenu.init(Carte_SSD))
{Serial.println("Carte non pas formatee."); return;}
// Afficher le contenu de la carte SD :
Serial.println("\nFichiers prsents sur la carte :");
Serial.println("Nom / date / Heure / taille");
Racine.openRoot(Contenu); }Deux critures
possibles.
Racine.ls(LS_R | LS_DATE | LS_SIZE);
En cas d'chec en ou en il y a sortie anticipe de la procdure
optionnels. LS_R si l'on dsire les sous-dossiers, LS_DATE si l'on
veut la date et l'heure et LS_SIZE si l'on veut la taille des fichiers.
COMPLMENTS : Aller sur http://www.mon-club-elec.fr/
pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieSD pour
avoir des informations complmentaires sur les fonctions name(),
isDirectory(), openNextFile() et rewindDirectory().
P 14
Mthodes de la bibliothque Servo.h.
Cette librairie permet une carte Arduino de contrler plusieurs
servomoteurs de modlisme. En standard ils permettent de positionner
et de maintenir laxe diffrents angles, habituellement entre 0 et 180.
Sur les cartes autres que la Mega, lutilisation de la librairie Servo.h
dsactive linstruction analogWrite() sur les broches 9 et 10, quil y
ait ou non un servomoteur branch sur ces sorties.
Le constructeur Servo dclare une variable de type Servomoteur.
On peut dclarer autant de variable Servo quon utilise de moteurs.
Ex : Servo Moteur_roulis ;
L'instruction attach prcise la broche de commande.
Ex : Moteur_roulis.attach(3) ;
On peut dfinir les limites de l'impulsion de commande
correspondant aux rotations limites du moteur :
NomMoteur.attach(broche, impls_min, impus_max); Par dfaut
les valeurs sont de 544 pour impuls_min et 2400 pour impuls_max.
Ex : Moteur_roulis.attach(3,1000,2000) ;
L'instruction detach dsassocie la variable Servomoteur de sa broche.
Si toutes les variables Servo sont libres, alors les broches 9 et 10
peuvent tre utilises pour gnrer de la PWM avec analogWrite().
Ex : Moteur_roulis.detach() ;
L'instruction write provoque sur un moteur standard son
positionnement l'angle donn en paramtre. Langle exprim en
degrs est compris entre 0 et 180. La largeur de limpulsion envoye
au servomoteur est ventuellement limite par les paramtres imposs
au pralable avec linstruction attach(broche, impls_min, impls_max)
Ex : Moteur_roulis.write(90) ; (Poritionne le moteur au neutre)
L'instruction writeMicroseconds permet d'imposer la dure de
l'impulsion au lieu de l'angle de positionnement.
Ex : Moteur_roulis.writeMicroseconds(1500) ;
Sur les moteurs standards, un paramtre de valeur 1000 s est la
position extrme dans un sens, 2000 est la position extrme dans le
sens inverse et 1500 est au centre. De nombreux fabricants dpassent
ces valeurs entre 700 et 2300 raison pour laquelle linstruction attach()
initialise par dfaut entre 544 et 2400. Repousser ventuellement ces
valeurs limites tant que le servomoteur continue se positionner.
P 31
display.drawLine(Xd, Yd, Xf, Yf,WHITE); ..
Procdure qui trace une ligne entre les deux points dont on prcise les
coordonnes. WHITE ou BLACK prcise si on trace en blanc ou en
noir. L'ordre de dfinition des extrmits est quelconque.
display.drawRect(Xo, Yo, Largeur, Hauteur,WHITE); (Voir Fig.1)
Procdure qui trace un rectangle dont on prcise les coordonnes de
l'Origine, la Largeur et la Hauteur. WHITE ou BLACK prcise si
on trace en blanc ou en noir. Largeur et hauteur peuvent avoir des
valeurs ngatives et sont alors tracs vers la gauche et vers le haut.
display.drawCircle(Xo, Yo, Rayon, WHITE); .
Procdure qui trace un cercle dont on prcise les coordonnes du
centre et la valeur du Rayon. WHITE ou BLACK prcise si on trace
en blanc ou en noir. Gre les dbordements de 127 x 63.
Affichages des textes.
display.setTextColor(WHITE); .
Procdure qui dfinit la "couleur" du texte. (Noir si BLACK.)
display.setTextColor(TEXTE,FOND); .
Procdure qui dfinit la couleur du texte puis du fond. Par exemple
Page 14
display.setTextColor(BLACK, WHITE); fait passer le texte en
"surbrillance" par inversion criture en noir sur fond blanc.
display.setCursor(X, Y); .
Positionne le curseur de la prochaine criture textuelle.
display.setTextSize(Taille); .
Dfinit la taille des caractres, la plus petite valeur tant 1. .
1 : Matrice 5x7, 2 : Le double, 3 : Le triple etc.
display.print(Donne); display.println(Donne); .
Affiche la donne partir de la position actuelle du curseur. Gre les
dbordements de la fentre 127 x 63, le texte dpassant du domaine
affichable sera ignor. Le format de la Donne peut tre : .
. display.println("Texte quelconque."); (1) .
. display.print(PI,8); Valeur et en option le nombre de dcimales.
display.println(1234, BIN); Valeur affiche en Binaire. .
display.print(1234, HEX); Valeur affiche en Hexadcimal. .
display.println(1234, OCT); Valeur affiche en Octal.
(1) : Les lettres, les chiffres et la ponctuation standard sont
correctement affichs ainsi que 128 autres caractres particuliers.
(Matrices standard ASCII au format 5x7 pour le coefficient 1.)
P 30 P 15
Mthodes de la bibliothque Adafruit_ssd1306syp.h. Mthodes de la bibliothque Stepper.h.
Cette librairie ne fournit que trois procdures, mais ces dernires sont
S pcifique l'afficheur graphique monochrome miniature OLED
128 x 64, cette bibliothque est suffisante pour mettre
facilement en uvre ce produit aussi bien pour du trac gomtrique
tout fait suffisantes pour grer un moteur pas pas dans un
programme pour Arduino. Elles permettent de configurer les paramtres
que pour de l'affichage de textes. relatifs au moteur utilis, et d'imposer ce dernier des mouvements
aussi bien dans le sens direct que dans le sens rtrograde.
Initialisations diverses.
Initialisations des paramtres relatifs au moteur utilis.
Adafruit_ssd1306syp display(broche_SDA, broche_SCL);
Cette directive doit tre place avant void setup() et prcise les deux Stepper Mon_moteur(Resolution, S1, S2, S3, S4); .
sorties binaires d'Arduino qui seront utilises pour interfacer l'I2C. Il Cette procdure cre une instance de la classe Stepper qui identifie
n'est pas utile de configurer ces deux broches en sorties. Mon_moteur un moteur pas pas connect aux sorties binaires S1,
display.initialize(); delay(100); . S2, S3 et S4. Si seulement deux broches sont dfinies, c'est que le
Instruction placer dans void setup() moteur est de type unipolaire. Cette procdure doit tre rencontre
avant toute utilisation de l'afficheur. dans setup() ou dans loop() avant toute utilisation du moteur. Le
Cette instruction se charge de dfinir paramtre Resolution dfinit le nombre de pas pour effectuer un
les deux broches affectes la ligne tour sur le moteur. Il ne faut pas tenir compte de la prsence d'un
I2C en sorties. Les broches A0 A5 ventuel rducteur. La Fig.1 montre
sont parfaitement utilisables en sorties. (Dclarations 14 19.) dans quel ordre doivent
Principe des d'affichages. tre ralises les liaisons S2 IN1 50

Page 15
lectriques si le moteur S4 IN2
Qu'il soit graphique ou texte, un affichage se fait toujours en deux utilis est un modle de S1 50
phases. La premire action consiste placer les "pixels" dans la IN3 Fig.1
type bipolaire comme le 50
mmoire tampon 128 x 64 de l'afficheur. La deuxime action consiste S3 IN4
28BYJ-48 par exemple.
transfrer l'affichage sur l'cran LCD avec l'instruction 50
Vitesse possible de commutation.
display.update(); cette ligne tant indispensable mme pour
l'instruction display.clear(); d'effacement de l'cran. Mon_moteur.setSpeed(Nb_tours_par_Minute); .
La Fig.1 prcise les valeurs des coordonnes pour les pixels. Cette procdure prcise la vitesse de rotation acceptable par le moteur
sans risquer de perdre des pas. Elle ne fait pas mouvoir le moteur,
Affichages graphiques. mais dfinit simplement la vitesse laquelle il tournera lors de l'appel
display.drawPixel(X, Y, WHITE); . . la procdure step(). Nb_tours_par_Minute est un long.
Procdure qui permet de grer l'afficheur point par point. Elle allume
Faire tourner le moteur.
le pixel de coordonnes X et Y si le paramtre de lumire est WHITE
ou teint le point si le paramtre est BLACK. Mon_moteur.step(Nb_pas); .
Active le moteur pour lui faire raliser Nb_pas la vitesse de rotation
X 0,127 dtermine par l'appel le plus rcent setSpeed() ce qui permet au
0,0
Taille du
programme de pouvoir modifier convenance la rapidit de la rotation.
Origine du
rectangle Cette fonction est "suspensive", c'est dire qu'il faut attendre que le
rectangle
L,H moteur ait fini de raliser les Nb_pas avant de passer l'instruction
suivante dans le programme. Le paramtre Nb_pas est un nombre
0,63 Y Fig.1 63,127 entier sign. Si le signe est positif le moteur tourne dans le sens direct.

Si le signe est ngatif la rotation sera rtrograde.

 P 16
Mthodes de la bibliothque AFMotor.h.
Cette librairie est prvue pour grer des moteurs courant continu en
utilisant le Shield ADAFRUIT montr sur la Fig.1 et spcifiquement
ddie l'interfaage de puissance de petites motorisations. Aprs l'avoir
dclare, AFMotor.h permet de contrler jusqu' quatre moteurs
courant continu en sens et en vitesse sur le Shield de d'ADAFRUIT.
Gestion des moteurs courant continu.
AF_DCMotor Mon_moteur(Port, Frquence PWM);
Ce constructeur pour un moteur courant continu doit tre utilis pour
chaque moteur inclus dans le projet. (Invoqu une seule fois par
moteur) Chaque instance doit avoir un nom diffrent. Le paramtre
Port peut prendre les valeurs de 1 4 et prcise le port de branchement
du moteur. L'alimentation du moteur se fait en PWM, le paramtre
Frquence PWM dfinit la frquence du signal rectangulaire gnr.
On peut utiliser les quatre options suivantes :
MOTOR12_64kHZ
MOTOR12_8kHZ 2kHZ n'est possible que sur #1 et
P 29
LCD.S u r b r i l l a n;c e ( b o o l e a n ) .
Si "true" crit et affiche les textes et les nombres en surbrillance.
Modifier des caractres spciaux.
F ondamentalement il suffit de remplacer les cinq
octets qui dfinissent l'un des caractres spciaux
qui ne sera plus utilis. L'appel se fait toujours avec le
. caractre textuel de son code ASCII. Par exemple on
dsire que 'Flche Gauche' de code ASCII 127 non utile pour le
programme en cours de dveloppement aprs rcriture de ses cinq
octets devienne ''. Le premier octet est relatif la colonne verticale
de gauche. Attention, le BIT de poids faible correspond au haut
de la matrice, et le poids fort au bas. L'inter caractres sur la 6 ime
colonne de droite est gnr automatiquement par la mthode
concerne avec un octet gal B00000000, raison pour laquelle
chaque caractre n'est reprsent que par cinq OCTETs.
Pour notre exemple la dernire ligne du tableau devient :
B00111100, B01000000, B01000001, B00100010, B01111100};

Page 16
MOTOR12_2kHZ
MOTOR12_1kHZ
F #2 mais pas sur #3 et #4. La table de gnration des matrices de caractres se trouve dans le
fichier Perso_ST7565.ccp de la bibliothque.
Si le paramtre Frquence PWM n'est pas prcis, la frquence de Gnration d'une matrice de 6 colonnes.
1Khz sera utilise par dfaut pour le dcoupage du signal. On peut crer un "pav" complet sans modifier la
Cette instruction s'utilise aprs la dclaration de la bibliothque, hors bibliothque. La technique consiste crer une
de la procdure d'initialisation voidsetup{}. procdure spcifique dans laquelle la matrice 6 x 8 est
Exemple : dfinie dans un petit tableau local la procdure.
#include <AFMotor.h> Chaque nouveau caractre coute 110 octets de programme et 6 octets
AF_DCMotor Mon_moteur_DC(1, MOTOR12_64KHZ); en mmoire dynamique. Quand on veut afficher le caractre spcial,
Pas pas
// Cration du moteur #1 avec PWM 64KHz. dans le programme on fait appel cette procdure. Exemple :
#1
Remarque : Les frquences Appel dans le programme : Damier();
les plus leves produisent void Damier() {// Laisse PTR sur le prochain Octet de
DC souvent un sifflement MEMOIRE aprs de caractre.
DC #4 moins audible au byte CAR_Special1[6] {B01010101, B10101010,
#1 Fig.1 fonctionnement, mais B01010101, 10101010, B01010101, B10101010, };
DC peuvent entraner un byte BarreV;
DC #3 couple infrieur avec for(byte Colne=0; Colne<6; Colne++)
#2
Pas pas certains moteurs. {BarreV = CAR_Special1[Colne];
#2 LCD.Envoyer_une_DONNEE(BarreV);} }
P 28
Police de caractres en mmoire de programme FLASH.
Actuellement la table de gnration des caractres construite pour
des matrices 6x8 est loge en mmoire de programme pour librer
totalement l'EEPROM et ne pas consommer de place en RAM
dynamique. De plus la bibliothque devient entirement
"autonome". Si l'on dsire modifier des caractres spciaux, il faut
modifier leurs cinq octets gnriques dans PERSO_ST7565.ccp
avec un quelconque diteur de texte.
Les Mthodes TEXTUELLES.
LCD.CURSEUR(byte X, byte Y); . sera pas ncessairement proportionnelle la vitesse programme.
Impose les coordonnes logicielles de la prochaine
criture d'un caractre sur l'cran. X et Y indiquent la
position du PIXEL situ en haut gauche de la matrice
qui dfinit le caractre. Contrairement la mthode
LCD.Positionne_curseur(Colonne, Secteur); ddie au trac
de "pavs verticaux", LCD.CURSEUR() qui gre des "matrices 6
x 8" peut placer le caractre des coordonnes quelconques sur
l'cran. La partie hors cran du caractre n'est pas affiche.
LCD.C R L F ( ) ;
Fait passer le curseur textuel en dbut de ligne suivante. Si le bas
de l'cran est dpass provoque un "schrolling" cran.
LCD.H O M E ( ) ;
Fait passer le curseur textuel en haut gauche de l'cran.
LCD.Decale_MEMOIRE(); (Voir Page 26.)
LCD.Decale_ECRAN(); (Voir Page 26.)
LCD.Affiche_TEXTE("Chane de caractres");
Affiche la chane de caractres partir de la position actuelle du
curseur textuel. Gre un semi passage la ligne si dbordement.
Un dbordement droite fait passer la ligne, mais coupe
ventuellement le caractre en cours. Si le dbordement se fait sur
la ligne du bas il y a gnration d'un "schrolling" cran.
LCD.Affiche_NOMBRE(Valeur numrique, Nb_decimales);
Affichera une valeur numrique quel que soit son type. Le nombre
de dcimales souhait est prcis dans Nb_decimales. La valeur
sera comprise entre 0 et 2. Si on propose une valeur suprieure
2 elle sera ramene 2. Si la consigne est 0, il n'y aura aucune
dcimale et le point dcimal n'est alors pas affich.
... / ...
P 17
Mon_moteur.setSpeed(Vitesse); .
Cette procdure peut dfinir tout moment la vitesse laquelle
tournera le moteur. La valeur du paramtre Vitesse sera comprise
entre les entiers 0 255. (0 : Plein ralenti / 254 : Vitesse maximale)
Exemple :
Mon_moteur_1.setSpeed(254); // La vitesse du n1 sera maximale.
Mon_moteur_3.setSpeed(127); // La vitesse du n3 sera moyenne.
Remarque : La rponse d'un moteur courant continu n'est pas forcment
linaire et dpend du couple rsistant. La vitesse de rotation relle ne
Mon_moteur. run(Mode); .
Cette procdure peut dfinir tout moment le mode de fonctionnement
du moteur. Les paramtres Mode valides sont : .
FORWARD : Rotation dans le sens direct. .
BACKWARD : Rotation dans le sens inverse. .
RELEASE : Coupe l'alimentation du moteur. (quivalent
l'instruction SetSpeed (0).) Le circuit d'ADAFRUIT ne gre pas un
Page 17
freinage dynamique, le moteur entrain par inertie peut prendre un
. certain temps avant de s'immobiliser. .
Exemple :
Mon_moteur.run(FORWARD); // Le moteur tourne dans un sens.
. delay(1000); // Durant une seconde.
Mon_moteur.run(BACKWARD); // Le moteur tourne dans l'autre sens.
Gestion des moteurs PAS PAS.
AF_Stepper Mon_pas_a_pas(Nb_Pas, Port); .
. Ce constructeur pour un moteur PAS PAS doit tre utilis pour
chaque moteur inclus dans le projet. (Invoqu une seule fois par
moteur). Chaque instance doit avoir un nom diffrent. Le paramtre
Port peut prendre les seules valeurs 1 et 2 et prcise le port de
branchement du moteur. (1 pour #1 et #2 et 2 pour #3 et #4 : Voir la
Fig.1) Le paramtre Nb_Pas prcise le nombre de pas par tour.
Cette instruction s'utilise aprs la dclaration de la bibliothque, hors
de la procdure d'initialisation voidsetup{}.
Exemple :
#include <AFMotor.h>
AF_Stepper Moteur1(48, 1); // 48 pas par tour / branch sur #1 & #2.
AF_Stepper Moteur2(200, 2); // 200 pas par tour / branch sur #3 & #4.
... / ...
 P 18
Mthodes de la bibliothque AFMotor.h. (Suite)
Mon_pas_a_pas.step(Nb_Pas, Sens, Mode);
Cette instruction commande la rotation du moteur pour Nb_Pas. Le
sens de rotation est prcis par le paramtre Sens qui peut prendre
les deux valeurs FORWARD et BACKWARD. Le paramtre Mode
dfini le type de commutation des bobines. Les options valides sont :
SINGLE : Une seule bobine est excite la fois.
DOUBLE : Deux bobines sont alimentes pour avoir plus de couple.
INTERLEAVE : Alterne entre simple et double pour gnrer un
demi-pas "entre les deux". Gnralement le fonctionnement est plus
doux, mais le demi-pas rduit la vitesse et la rotation de moiti.
MICROSTEP : Les bobines adjacentes sont alimentes ou libres par
des rampes pour engendrer un certain nombre de "micro-tapes" entre
deux pas complets. Il en rsulte une rsolution plus fine et une rotation
plus lisse, mais le mouvement s'accompagne d'une perte de couple.
NOTE : L'instruction est "mobilise" dans une boucle de programme
tant que le moteur n'a pas effectu les Nb_Pas. Si on dsire un
mouvement simultan des deux moteurs possibles, il faut gnrer
la chronologie par utilisation de l'instruction onestep() insre dans
une boucle qui traite les deux moteurs en grant le nombre de pas
effectus par chacun d'eux. (Voir aussi l'encadr en bas de p19)
Exemple :
Moteur1.step(100, FORWARD, DOUBLE);
// Faire 100 pas dans le sens direct avec couple augment.
Moteur2.step(300, BACKWARD, MICROSTEP);
// Faire 300 pas dans le sens rtrograde avec rotation lisse.
Mon_pas_a_pas.setSpeed(RPM); . horaire tous les degrs donc, plus le rayon impos devient
Cette instruction qui peut tre invoque tout moment et convenance
dans le programme dfinit la vitesse de rotation qui sera impose au
moteur pas pas. La valeur indique est exprime en tours par
minute. Elle ne sera respecte que si : . mosaque d'cran qui ne
Le nombre de pas par tout du moteur a t correctement dfinie. .
Le couple rsistant ne dpasse pas le couple moteur.
Exemple :
Moteur1.setSpeed(10); // Vitesse de 10 tours par minutes pour Moteur1.
Moteur2.setSpeed(20); // Vitesse de 20 tours par minutes pour Moteur2.
... / ...
P 27
LCD.CADRE(int x, int y, int X, int Y,boolean Allume); .
. Trace un cadre (Rectangle creux.) dont on dfinit dans un ordre
quelconque les extrmits de l'une de ses deux diagonales. Traite
entirement l'ordre dans lequel on donne ces "angles" ainsi que les
dbordements d'cran. (Dbut avec x et y et Fin avec X et Y.)
LCD.RECTANGLE_plein(int x, int y, int X, int Y,boolean Allume);
Trace un rectangle "plein" dont on dfinit dans un ordre quelconque
les extrmits de l'une de ses deux diagonales. Traite entirement
l'ordre dans lequel on donne ces "coins" ainsi que les dbordements
d'cran. (Dbut avec x et y et Fin avec X et Y.)
LCD.CERCLE(int X, int Y, int R, boolean Allume); .
Trace un cercle dont on indique les coordonnes du centre avec X
et Y et la valeur du rayon avec R. Seule la partie "visible" sera trace
les dbordements d'cran tant entirement grs. Les coordonnes
du centre peuvent tre ngatives sans problme.
LCD.ELLIPSE(int X, int Y, int RX, int RY, boolean Allume);
Trace une ellipse dont on indique les coordonnes du centre avec
X et Y, le "rayon" horizontal avec RX et le "rayon" vertical avec RY.
Page 18
Seule la partie "visible" sera trace les dbordements d'cran tant
entirement grs. Les coordonnes peuvent tre ngatives sans problme.
LCD.ARC(int X, int Y, int R, int Angle_debut, int Angle_fin,
boolean Allume); Trace un arc de cercle dont on indique les
coordonnes du centre avec X et Y et la valeur du rayon avec R. Les
Angle_debut et Angle_fin sont indiqus en partant du "Nord" et
doivent tre POSITIFS. Seule la partie "visible" sera trace les
dbordements d'cran tant entirement grs. Les coordonnes du
centre peuvent tre ngatives. Le trac est effectu dans le sens
grand, plus les PIXELs reprsentatifs seront spars.
Sur la Fig.2 ci-contre les
lments hors de la
seront pas "tracs" sont
reprsents en jaune,
Fig.2 alors que la partie en
rouge est celle qui
modifiera les PIXELs.
... / ...
P 26
LCD.Blancking_Ecran();
Blanchi (Ou noirci en fonction du type d'afficheur.) entirement
l'cran sans modifier [Colonne / Secteur].
LCD.Inverser_ecran();
Inverse l'tat des PIXELs de l'cran et conserve[Colonne / Secteur].
LCD.Remplir_et_affiche_Ecran(Octet); (Octet : Huit pixels.)
Remplit l'cran de pavs sans modifier [Colonne / Secteur].
LCD.Afficher_MEMOIRE();
Rafraichi la mosaque de l'cran avec la totalit du contenu de
[MEMOIRE] sans modifier [Colonne / Secteur].
LCD.Decale_MEMOIRE();
Dcale la [MEMOIRE] d'un Secteur vers le haut sans afficher le
rsultat. (Sera surtout utile pour du texte.)
LCD.Decale_ECRAN();
Dcale la mosaque de l'cran d'un Secteur vers le haut sans
modifier [Colonne / Secteur]. (Sera surtout utile pour du texte.)
Les Mthodes GRAPHIQUES.
NOTE : La notion de "Allumer" ou "teindre" sera directement
fonction du type d'afficheur ST7565 utilis. Pour rendre compatible
les effets obtenus par rapport aux informations de ce document, il
suffit dans void setup de faire appel la procdure
LCD.Inverser_ecran(); si le modle utilis dans l'application
prsente une logique inverses. Pour toutes les mthodes le paramtre
Allume prcise si l'lment sera trac en "Blanc" si la valeur passe
la mthode est true ou 1, ou en "Noir" si elle vaut false ou 0.
LCD.PIXEL(int X, int Y, boolean Allume);
Procdure qui modifie un PIXEL individuellement. Les coordonnes
du PIXEL X de 0 127 et Y de 0 63 peuvent tre quelconques, (Car
utilises pour tracer les autres entits gomtriques.) mais il n'y aura
pas d'action si elles sont hors de la mosaque d'cran.
LCD.LIGNE(int x, int y, int X, int Y,boolean Allume);
Trace la ligne dont on spcifie les coordonnes du dbut avec x et y
et de la fin avec X et Y. L'ordre dbut et fin peut tre quelconque, et
les extrmits peuvent tre hors de la mosaque d'cran. Seule la
partie "visible" sera trace les dbordements d'cran tant entirement
grs. Les coordonnes peuvent tre ngatives sans problme.
... / ...
P 19
. Mon_pas_a_pas.release(); .
Cette instruction sans paramtre permet de supprimer le courant de
maintien du moteur dans le but de rduire la temprature dissipe dans
. les bobines. Mais le moteur ne fournit aucun couple et la charge peut
dans ce cas l'entrainer facilement. Exemple :
Moteur1.release(); // Coupe l'alimentation des bobines du Moteur1.
Mon_pas_a_pas. onestep(Sens, Mode); .
. Cette instruction commande la rotation du moteur pour un seul pas.
Le sens de rotation est prcis par le paramtre Sens qui peut prendre
les deux valeurs FORWARD et BACKWARD. Le paramtre Mode
. dfini le type de commutation et n'accepte pas MICROSTEP. De plus
la vitesse n'est plus gre par la procdure setSpeed(RPM). Il faut
imposer un petit dlai entre chaque pas pour imposer la vitesse.
. Exemple :
Moteur1.onestep(FORWARD, DOUBLE); delay(1);
// Un pas en mode DOUBLE effectu sur Moteur1.
Gestion des SERVOMOTEURS.
Page 19
Le circuit imprim de gestion des moteurs ne fait que dporter sur deux
connecteurs ddis aux servomoteurs la masse et le +5Vcc d'Arduino.
Ces deux connecteurs ont trois broches. Deux pour l'alimentation du
servomoteur et une pour son pilotage. Il faut donc utiliser la bibliothque
Servo.h dcrite en page 14, usant en pilotage les sorties PWM 9 et 10.
La bibliothque complmentaire AccelStepper.h.
Cette librairie qui inclut Stepper.h de la page 7 fournit une interface
oriente objet pour grer deux, trois ou quatre moteurs pas pas.
. Elle amliore la bibliothque de base de plusieurs faons :
Gre les acclrations et les ralentissements.
Gre simultanment et indpendamment plusieurs moteurs.
Pilote des moteur de structures diffrentes.
Prend en charge des pilotes de moteurs PAS PAS comme le
. "Sparkfun EasyDriver" bas sur le circuit intgr spcialis 3967.
Les vitesses trs lentes sont prises en charge.
Proposant des fonctions trs labores, l'auteur de cette librairie
donne un lien pour tlcharger une documentation complte sur :
http://www.airspayce.com/mikem/arduino/AccelStepper/
P 20
Mthodes de la bibliothque LiquidCrystal.h.
LiquidCrystal.h permet une carte Arduino de contrler un afficheur
LCD pilot par un "chipset" de type Hitachi HD44780 ou un compatible
qui quipe sur la plupart des crans LCD alphanumrique. Elle autorise
en outre aussi bien la commande avec 4 bits que par le mode 8 bits.
LiquidCrystal lcd(RS, RW, Enable, d0, d1, d2, d3, d4, d5, d6, d7);
Dclaration globale pour crer un objet lcd de type LiquidCrystal.
RW : Paramtre facultatif. Dans ce cas relier RW la masse d'Arduino.
d0, d1, d2, d3 sont galement facultatifs. Si omis pilotage quatre bits.
Les diverses syntaxes possibles qui sont diffrencies par le nombre
de paramtres donns la fonction sont :
LiquidCrystal lcd(RS, Enable, d4, d5, d6, d7);
LiquidCrystal lcd(RS, RW, Enable, d4, d5, d6, d7);
LiquidCrystal lcd(RS, Enable, d0, d1, d2, d3, d4, d5, d6, d7);
LiquidCrystal lcd(RS, RW, Enable, d0, d1, d2, d3, d4, d5, d6, d7);
(Dans cet exemple lcd est l'identificateur de l'objet dclar)
lcd.begin(Cols,Lignes); (Dclaration dans void setup())
P 25
LCD.Afficheur_en_veille();
Procdure qui Passe l'afficheur en veille et teint les trois couleurs.
(L'afficheur passe en consommation minimale.)
LCD.Afficheur_en_service;
Ractive l'afficheur et allume les trois couleurs.
LCD.Envoyer_une_DONNEE(Octet); .
Procdure qui Affiche le pav vertical Octet aux coordonnes
[Colonne, Secteur] actuelles. (Voir Fig.1 en page 23) Comme
l'index horizontal interne de l'afficheur est automatiquement dcal
d'une position droite, Colonne est incrmente pour pointer le
. prochain "pav vertical" sur la mosaque de l'cran.
LCD.Impose_PAGE(Secteur); (0 < Secteur < 8) .
Positionne verticalement la prochaine criture sur Secteur.
LCD.Impose_COLONNE(Colonne); (0 < Secteur < 128)
Positionne horizontalement la prochaine criture sur Colonne.
LCD.Positionne_curseur(Colonne, Secteur); ..
Positionne l'emplacement d'criture du prochain "pav vertical" aux
.

Page 20
coordonnes Colonne, Secteur dans la mosaque de l'cran. Les
Prcise les dimensions de la matrice de caractres de l'cran. . limites sont prcises ci-dessus ou sur la Fig.1 en page 23.
Doit tre appele avant les autres instructions de la bibliothque. LCD.Contraste(Contraste); .
lcd.setCursor(Col,Ligne); . Procdure qui impose la valeur du paramtre byte Contraste en
Dfinit la position du curseur o commencera la prochaine criture contraste dynamique. La documentation en ligne prcise des
sur l'cran. (0 est la premire ligne ou la premire colonne) valeurs comprises entre et 0x63. (Je conseille entre 27 pour le
Noir et 50 Maxi pour le Blanc, valeurs donnes en dcimal.)
lcd.cursor(); lcd.noCursor(); .
Valide ou supprime l'affichage du curseur de position d'criture. NOTE : L'afficheur ST7565 ne dispose pas d'une mmoire
lcd.home(); . interne accessible par l'utilisateur. Pour palier cette faiblesse
un tableau [MEMOIRE] est cr dans l'instance de l'objet LCD.
Place le curseur de la prochaine criture en haut et gauche.
En utilisation du programme, certaines mthodes agissent
lcd.clear(); . directement sur l'cran et mettent jour [MEMOIRE]. D'autres
Efface tous les caractres de l'cran LCD. . permettent de modifier directement le contenu de [MEMOIRE]
Comme pour home positionne le curseur en haut et Curseur de sans en visualiser le changement sur l'cran. Dans la description
Blink de la bibliothque, faire rfrence l'cran correspond
gauche de l'cran du module d'affichage.
l'affichage, alors que [MEMOIRE] correspond la modification
lcd.blink(); lcd.noBlink(); .
du tableau sans incidence sur l'cran sauf si c'est prcis.
Valide ou supprime l'affichage du gros curseur clignotant
qui remplit intgralement la matrice 5/8. Le curseur LCD.Effacer_Ecran(); .
simple reste visible en permanence s'il est valid. Efface entirement l'cran sans modifier [Colonne / Secteur].
F ... / ...
P 24
Crer une instance de l'objet Perso_ST7565.h .
Le programme doit commencer par la directive :
#include <PERSO_ST7565.h>
Si l'on dsire pouvoir traiter librement le rtro-clairage il faut dfinir
les broches de pilotage par des identificateurs. Par exemple :
#define Retro_Bleu 9 NOTE : Ici 9,10 et 11 sont choisies
#define Retro_Rouge 10 pour pouvoir les traiter en PWM.
#define Retro_Vert 11
Ensuite on doit crer une instance (Nomme ici LCD.) de l'objet :
PERSO_ST7565 LCD = PERSO_ST7565
(6,7,8,Retro_Bleu,Retro_Rouge,Retro_Vert,12);
Les paramtres dans l'ordre dsignent la broche qui pilotera RST,
A0, SCLK, Le Bleu, Le Rouge, le Vert et SID. Dans cet exemple
A0 est pilote par la sortie binaire 6, SCLK par 7 ... SID par 12.
(Dans cet exemple l'utilisateur regroupe toutes les broches de
commande en laissant libre la LED Arduino 13 et en permettant de
commander les trois sorties du rtroclairage en analogique PWM.)
partir d'ici l'objet instanci est compltement initialis, les broches
sont configures, l'cran est mis en service et effac et l'on peut
convenance utiliser les diverses mthodes proposes par la
bibliothque. Par exemple LCD.ELLIPSE(0,0,60,30,1);
Mthodes de base.
LCD.Envoyer_une_COMMANDE(Octet);
Procdure qui envoie la commande prcise par Octet : .
B11001000 : Balayage vertical normal du Haut vers Bas.
B11000000 : Balayage vertical invers du BAS vers le Haut.
B10100000 : Balayage horizontal normal de Gauche Droite.
B10100001 : Balayage horizontal invers de Droite Gauche.
B10100101 : Allume tous les points.
B10100100 : Retour au mode normal.
B11001000 : Passer en mode de contraste dynamique. Doit tre
suivi de la valeur entre 32 et 41 en dcimal. (0 63 dans la doc.)
Exemple : LCD.Envoyer_une_COMMANDE(41);
B10100110 : Ecran NORMAL. (criture allume, fond noir.)
... / ...
P 21
lcd. noDisplay(); lcd.display(); .
noDisplay efface l'cran et le curseur mais conserve l'tat en mmoire.
display rtablit l'affichage du texte et du curseur s'il est valid.
lcd.scrollDisplayLeft(); lcd.scrollDisplayRight(); .
Dcale l'intgralit de l'affichage, y compris le curseur d'une position
gauche ou droite. Les caractres "entrants sont des "espaces".
lcd.leftToRight(); lcd.rightToLeft(); .
Dfinit le sens de dcalage du curseur de la gauche vers la droite
(Valeur par dfaut) ou de la droite vers la gauche lors d'un affichage.
lcd. autoscroll(); .
Chaque caractre sera crit la position actuelle du curseur,
immdiatement suivi d'un dcalage d'une position pour tout l'cran.
Le dcalage de l'cran est fonction du sens impos par scrollDisplay
Left ou Right. Le recyclage interne des caractres n'est pas spcialement
vident. L'instruction lcd.noAutoscroll(); annule ce mode de
fonctionnement et retourne au dfilement classique.
Page 21
lcd. print(); .
Cette fonction est analogue au print de la librairie Serial que l'on
pourra consulter et prsente un comportement similaire pour les
divers formats reconnus. Elle permet d'afficher des textes et des
nombres reprsentatif des valeurs de variables sur un module LCD.
lcd.print("Texte"); ou lcd.print('Caractre');
.
lcd.print(Data); Affiche la valeur numrique de la variable Data.
lcd.print(Data, BASE); BIN : Binaire pur.
DEC : Dcimal.
L' option BASE
est facultative. HEX : Hexadcimal.
OCT : Octal.
. Data : char, byte, int, long, float ou string
. lcd. write(); .
Cette fonction est oriente caractre. Elle fait afficher au module LCD
le caractre dont on fournit le code ASCII en dcimal. Si la valeur
. du paramtre est prcde de B le code est alors exprim en binaire,
les zros en tte peuvent tre omis. Exemples de codage :
... / ...
 P 22 P 23

lcd.write(57); (Affiche "9" car par dfaut paramtre en dcimal) Mthodes de la bibliothque Perso_ST7565.h.
lcd.write(B111101); (Affiche "=", paramtre en Binaire)
lcd.write(B01000110); (Octet complet, affiche "F") S pcifique l'afficheur LCD avec
rtroclairage trichrome ST7565,
cette bibliothque gre globalement des
Il est tout fait possible de passer comme paramtre afficher un
tracs gomtriques et l'affichage de textes
caractre issu de la ligne srie USB :
et de variables numriques.
void loop() { // Attendre l'arrive d'un caractre sur le port srie. Gestion par pavs verticaux de l'cran.
if (Serial.available()) { Gomtriquement la matrice de points est constitue de 128
lcd.clear(); delay(100); COLONNEs et de huit SECTEURs nomm galement PAGEs dans
while (Serial.available() > 0) // Lire tous les caractres reus. certaines documentations. Pour modifier ce qui sera affich l'cran,
{lcd.write(Serial.read); } } } il faut intervenir directement sur les BITs des OCTETs dont on doit
lcd. createChar(Numro, Tableau); . indiquer les "coordonnes". Le traitement des coordonnes n'est pas
Les modules LCD permettent de se crer jusqu' huit caractres immdiat, mais la bibliothque s'en charge. Toutefois, comme la
personnaliss dsigns par Numro dont la plage va de 1 8. procdure Envoyer_une_DONNEE(Octet); dpose son paramtres
L'apparence de chaque caractre se dfinit par un tableau de huit aux coordonnes gres par la bibliothque, il importe de savoir
comment la rpartition gomtrique logicielle est effectue :
octets chacun relatif l'une des lignes. Seuls les cinq bits de poids
Considrons la Fig.1 sur laquelle on constate que les COLONNEs
faibles dcrivent les pixels de la matrice du caractre. Pour afficher un

Page 22
sont numrotes de 0 127, et les SECTEURs entre 0 et 7. Le tout
caractre personnalis sur lcran, utiliser linstruction : .
premier octet qui constitue le "pav vertical" colori en bleu se
lcd.write(Numro);
trouve en position [0,0]. Le
L'exemple de construction d'un caractre spcifique donn en Fig.1 est
rectangle rouge est contenu dans
relatif la gnration du caractre "". On peut coder le tableau de SECTEUR 0
l'octet de coordonnes [3,5] et
dfinition en binaire ou en dcimal. (Et mlanger les deux) En binaire il
ainsi de suite. Le dernier octet
est inutile de donner les zros en tte. Exemple pour le "" : SECTEUR 1 en bas tout droite se trouve en
byte Ccedille[8] = {0,14,17,16,17,14,4,6}; position [7,127].
byte Ccedille[8] = {0,B1110,B10001,B10000,B10001,14,4,6}; SECTEUR 2 Pour modifier un octet dans la
Le petit programme Caracteres_Speciaux_LCD.ino donne un Fig.1 mmoire d'cran, il faut au
exemple d'utilisation de gnration
Fig.1 Total = 15 de caractres personnaliss. Surtout
pralable positionner le curseur
16 8 4 2 1 aux coordonnes dsires dans
il intgre les tableaux relatifs aux COLONNE 127 "la surface de l'cran" avec la
Lignes du caractre
Lignes du curseur

accentus qui n'existent pas dans la procdure Positionne_curseur

liste initiale, et donne une meilleure ( Colonne, Secteur). Notez
prsentation aux caractres qu'il existe des afficheurs
minuscules "g", "j", "p", "q" et "y" COLONNE 0 logique d'illumination positive,
qui d'origine ne sont pas trs beaux. et des composants de type
NOTE : "Sur Internet" Numro est suppos SECTEUR 7 ngatif. "Noir" et "Allum"
varier entre 0 et 7 et non entre 1 et 8 . seront fonction du type utilis.
... / ... ... / ...