Classe de première STI2D

TP Arduino
Table des matières
1. Installation et configuration de la carte Arduino..............................................................................................................2
1.1. Carte Arduino...........................................................................................................................................................2
1.2. Le shield d'extension E/S.........................................................................................................................................2
1.3. Structure d’un programme.......................................................................................................................................3
1.4. Interface de développement.....................................................................................................................................3
2. Utilisation de la sortie numérique.....................................................................................................................................4
2.1. Clignotement d'une LED..........................................................................................................................................4
2.2. Clignotement de 2 LED...........................................................................................................................................5
3. Utilisation de l'entrée numérique......................................................................................................................................6
3.1. Détection d'un Bouton Poussoir...............................................................................................................................6
4. Utilisation de l’entrée analogique.....................................................................................................................................7
4.1. Mesure de l’éclairement...........................................................................................................................................7
4.2. Télémétrie................................................................................................................................................................9
4.2.1. Capteur SRF05...........................................................................................................................................................9
4.2.2. Capteur Ultrasonic Ranger.......................................................................................................................................10
4.3. Simulation store électrique.....................................................................................................................................11
5. Utilisation de la sortie MLI.............................................................................................................................................14
5.1. Commande d’un moteur à courant continu............................................................................................................14
5.2. Commande d’un moteur à l'aide d'un potentiomètre.............................................................................................16
5.3. Programmation d'un moteur...................................................................................................................................17
5.4. Servo moteur..........................................................................................................................................................19
6. Afficheur LCD................................................................................................................................................................21
7. Modules..........................................................................................................................................................................23
shields...........................................................................................................................................................................23
8. Références......................................................................................................................................................................24

5-TP_arduino.odt 1
 Classe de première STI2D

1. Installation et configuration de la carte Arduino

1.1. Carte Arduino
Nous utiliserons une carte Arduino Uno. Elle emploi un microcontrôleur ATMEGA328P alimenté en 5 V. Il y a 14
entrées/sorties numériques dont 6 sont utilisables en PWM1. Il y a 6 entrées analogiques. Le microcontrôleur possède un
CAN2 avec 10 bits de résolution. Sur la carte, il y a un circuit qui permet de gérer facilement l’USB 3 qui peut alimenter
la carte.

• Mémoire Flash 32 ko
• Mémoire RAM 2 ko
• Mémoire EEPROM 1 ko
• Fréquence d’horloge 16 MHz
• Courant max. E/S40 mA
Pour en savoir plus, consultez la page : http://arduino.cc/en/Main/ArduinoBoardUno

1.2. Le shield d'extension E/S

Le shield d'extension E/S fournit un
moyen facile de connecter des capteurs
ou des servos pour la carte Arduino. Il
augmente le nombre d' E/S numériques et
analogiques. Il fournit également des
broches PWM distinctes qui sont
compatibles avec le connecteur de servo
standard. La prise de communication
fournit un moyen extrêmement facile à
brancher un module sans fil, tel le
module APC220 RF module ou le
module DF-Bluetooth. Il dispose d'une
entrée de puissance individuelle pour les
servos.

1 Pulse Width Modulation (ou MLI pour modulateur de largeur d’impulsion)

2 Convertisseur Analogique Numérique
3 Universal Serial Bus
5-TP_arduino.odt 2
 Classe de première STI2D

1.3. Structure d’un programme

Un exemple de programme est donné ci-dessous.

• Le commentaire de description du programme, appelé sketch, débute par /* et se termine par */.
• Puis il est placé la définition des constantes et des variables avec les instructions const et int.
• Vient ensuite la configuration des entrées / sorties avec l’instruction void setup(). La suite d’instructions est
précédé de { et se termine par }.
• On définit par l’instruction void loop() la programmation des interactions et comportements. La suite
d’instructions est précédé de { et se termine par }.

1.4. Interface de développement

Pour utiliser l’interface de développement :

1. Lancer le logiciel Arduino .

2. Vérifier que la carte Arduino Uno est bien prise en compte par : Outils > Type de carte > Arduino Uno.

5-TP_arduino.odt 3
 Classe de première STI2D

3. Brancher la carte sur un port USB. Vérifier que le port COM est bien configuré. Outils > Port série > COM X.
4. Vérifier que le port COM X est bien reconnu par windows : Panneau de Configuration > Système et sécurité >
Gestionnaire de périphériques > Ports : Arduino Uno (COM X).

2. Utilisation de la sortie numérique

2.1. Clignotement d'une LED
Ouvrir le fichier Blink par : Fichier > Exemples > 01.Basics > Blink
Pour comprendre la syntaxe et le rôle d’une instruction, utiliser la page : http://arduino.cc/en/Reference/HomePage
1. Réaliser le schéma de montage ci-dessous (faire attention au sens de polarisation de la LED).
Broche 12 : module LED

avec shield
extension I/O
2. Modifier le programme de telle façon que la sortie sur laquelle on connectera la LED soit la sortie 12.
3. Modifier les instructions pour que la période soit de 1 s et la durée d’allumage de la LED 100 ms.
4. Lancer l’exécution du programme en cliquant sur le bouton en dessous Édition :

/*
clignotement diode
*/

const int led = 12; // broche 12 pour la LED

// cette fonction ne s'exécute qu'une seule fois

void setup()
{
pinMode(led, OUTPUT); // on définit la broche en sortie
}

// cette fonction boucle indéfiniment

void loop()
{
digitalWrite(led, HIGH); // led allumée

5-TP_arduino.odt 4
 Classe de première STI2D
delay(100); // allumé 100ms
digitalWrite(led, LOW); // led éteinte
delay(100); // éteint 100ms
}

2.2. Clignotement de 2 LED

1. Modifier le programme pour que deux LED s’allument en opposition de phase comme dans le tableau suivant :

LED 1 Broche 11 Allumée Éteinte

LED 2 Broche 12 Éteinte Allumée

2. Modifier le schéma de montage comme indiqué ci-dessous :

Broche 11 : module LED1
Broche 12 : module LED2

/*
clignotement 2 diodes alternées
*/

const int led1 = 11; // broche 11 pour la LED 1

const int led2 = 12; // broche 12 pour la LED 2

// cette fonction ne s'exécute qu'une seule fois

void setup()
{
pinMode(..., OUTPUT); // on définit la LED 1 en sortie
pinMode(..., OUTPUT); // on définit la LED 2 en sortie
}

// cette fonction boucle indéfiniment

void loop()
{
// à compléter
// ...
delay(1000); // durée 1s

// à compléter
// ...
delay(1000); // durée 1s
}

5-TP_arduino.odt 5
 Classe de première STI2D

Pour voir le résultat, cliquer sur l'image

3. Utilisation de l'entrée numérique

3.1. Détection d'un Bouton Poussoir
1. Réaliser le schéma de montage ci-dessous (faire attention au sens de polarisation de la LED).
On utilisera un bouton poussoir (BP) qui commandera une LED à travers la carte Arduino.
Broche 4 : module LED
Broche 3 : module BP

2. Modifier ce programme pour que la carte Arduino commande la LED lors de la pression du bouton.
/*

5-TP_arduino.odt 6
 Classe de première STI2D
détection bouton poussoir
*/

const int led = ...; // broche 4 pour la LED

const int button = 3; // broche 3 pour le bouton poussoir

// the setup function runs once when you press reset or power the board
void setup()
{
pinMode(led, ...); // on définit la led en sortie
pinMode(button, ...); // on définit le bouton en entrée
}

// the loop function runs over and over again forever

void loop()
{
// lecture bouton
if ( digitalRead(button) == ... )
digitalWrite(led, ...); // led allumée
else
digitalWrite(led, ...); // led éteinte

delay(...); // stabilisation 200 ms

}

Pour voir le résultat, cliquer sur l'image

4. Utilisation de l’entrée analogique

4.1. Mesure de l’éclairement
Le capteur de luminosité utilisé est le LDR VT935G (ou équivalent série VT900).

5-TP_arduino.odt 7
 Classe de première STI2D

Par effet photovoltaïque, l'énergie rayonnante est transformée en énergie électrique.

La résistance interne du capteur est inversement proportionnelle avec la luminosité sur une échelle logarithmique.
1. Réaliser le schéma de montage ci-dessous :
Broche 9 : module LED
Broche A0 : module capteur luminosité

2. Visualiser la luminosité mesurée.

1. ouvrir un terminal
2. Régler la vitesse de
communication à 9600 bauds
3. Obturer le détecteur
4. Relever les valeurs :
- avec lumière
- sans lumière
5. En déduire la valeur de seuil

3. Modifier le programme ci-dessous pour régler le seuil de détection qui allumera LED.
/*
détection luminosité
*/

const int led = 9; // broche 9 pour la LED

const int lux = ...; // broche analogique A0 pour le capteur

// cette fonction ne s'exécute qu'une seule fois

void setup()
{
pinMode(...); // on définit la broche 9 en sortie

Serial.begin(9600); // initialise la vitesse du port série

}

// cette fonction boucle indéfiniment

5-TP_arduino.odt 8
 Classe de première STI2D
void loop()
{
int value = analogRead(...); // lecture capteur
Serial.println(value); // affichage valeur sur terminal série

if ( value < 0 ) // détection du seuil de luminosité

digitalWrite(led, ...); // led allumée
else
digitalWrite(led, ...); // led éteinte

delay(10); // stabilisation 10 ms
}

4.2. Télémétrie
On veut mesurer une distance par télémétrie à ultrason.

4.2.1. Capteur SRF05

Le capteur SRF05 et un émetteur récepteur d'ultrason (40 kHz), d'une portée allant théoriquement de 1 à 400 cm sur un
angle de 30°. Il permet l'utilisation de 1 ou de 2 broches pour l’émission/réception (la deuxième solution accélère le
traitement).
1. Réaliser le schéma de montage ci-dessous :
Broche 4 : Trigger
Broche 7 : Echo
Broche 8 : LED

2. Modifier le programme pour que la LED s'allume lorsque la distance à un obstacle est inférieure à 20 cm.
/*
Télémétrie par ultrason
*/

const int led = ...; // broche 8 pour la LED

const int emetteur = ...; // broche 7 pour envoi signal
const int recepteur = ...; // broche 4 pour réception signal

/* Routine d'initialisation */
void setup()
{
Serial.begin(9600); // Initialisation port COM

pinMode(...); // LED en sortie

pinMode(...); // signal en sortie
pinMode(...); // écho en entrée

5-TP_arduino.odt 9
 Classe de première STI2D
digitalWrite(emetteur, LOW);
}

void loop()
{
// envoi salve (impulsion émettrice)
digitalWrite(emetteur, HIGH);
delayMicroseconds(10);
digitalWrite(emetteur, LOW);

// Traitement du rebond de l’impulsion

long distance = pulseIn(recepteur, HIGH);
distance /= 58; //Traduction en cm

// affichage distance sur terminal série

Serial.print("Distance : ");
Serial.print(...);
Serial.println(" cm");

if ( distance < ... ) // seuil de distance minimale (en cm)

digitalWrite(...); // led allumée
else
digitalWrite(...); // led éteinte

delay(50);
}

4.2.2. Capteur Ultrasonic Ranger

1. Connecter le capteur selon le montage ci-dessous :

2. Modifier le programme pour que la LED s'allume lorsque la distance à un obstacle est inférieure à 20 cm.
/*
Télémétrie par ultrason avec librairie ultrasonic
*/

#include <Ultrasonic.h> // https://github.com/Seeed-

Studio/Grove_Ultrasonic_Ranger

const int led = ...; // broche 8 pour la LED

const int capteur = 7; // broche 7 pour capteur US

Ultrasonic ultrasonic(capteur); // initialisation capteur US

/* Routine d'initialisation */
void setup()
{
Serial.begin(9600); // Initialisation port COM

5-TP_arduino.odt 10
 Classe de première STI2D

pinMode(...); // LED en sortie

}

void loop()
{
long distance = ultrasonic.MeasureInCentimeters();

// affichage distance sur terminal série

Serial.print("Distance : ");
Serial.print(...);
Serial.println(" cm");

if ( distance < ... ) // seuil de distance minimale

digitalWrite(...); // led allumée
else
digitalWrite(...); // led éteinte

delay(50);
}

4.3. Simulation store électrique

On va simuler le fonctionnement d'un store électrique automatique.
A partir d'un certain seuil de luminosité, le programme déclenche un moteur (LED) qui devra s'arrêter lorsqu'il arrive en
buté (BP).
1. Réaliser le schéma de montage ci-dessous :
Broche 4 : module BP
Broche 9 : module LED
Broche A0 : module capteur luminosité

2. Modifier le programme de la mesure de l'éclairement pour que la LED s'éteigne quand le BP est enfoncé en
vous aidant du tableau ci-dessous.

Seuil atteint BP enfoncé LED

oui oui OFF
oui non ON
non oui OFF
non non OFF
/*

5-TP_arduino.odt 11
 Classe de première STI2D
simulation store électrique
*/

const int BP = ...; // broche 4 pour le BP

const int led = ...; // broche 9 pour la LED
const int lux = ...; // broche analogique A0 pour le capteur

// cette fonction ne s'exécute qu'une seule fois

void setup()
{
...; // on définit la broche 4 en entrée
...; // on définit la broche 9 en sortie

Serial.begin(9600); // initialise la vitesse du port série

}

// cette fonction boucle indéfiniment

void loop()
{
int bouton = ...; // lecture BP
int value = ...; // lecture capteur
Serial.println(value); // affichage valeur sur terminal série

if ( ... && ... ) { // détection du seul de luminosité

...; // led allumée
else
...; // led éteinte

delay(10); // stabilisation 10 ms
}
3. En cas de vent trop violent, le moteur ne doit pas être déclenché même si la lumière est trop importante.
Modifier le tableau pour prendre en compte le vent mesuré à l'aide d'un anémomètre qui sera simulé à l'aide
d'un potentiomètre.
4. Réaliser le schéma de montage ci-dessous :
Broche 4 : module BP
Broche 9 : module LED
Broche A0 : module
capteur luminosité
Broche A3 : potentiomètre

5. Modifier le programme précédent pour que la LED s'éteigne quand on tourne le potentiomètre de plus d'un
demi tour.
/*
simulation store électrique - v2
*/

5-TP_arduino.odt 12
 Classe de première STI2D
const int BP = ...; // broche 4 pour le BP
const int led = ...; // broche 9 pour la LED
const int lux = ...; // broche analogique A0 pour le luxmètre
const int vent = ...; // broche analogique A3 pour le potentiomètre

// cette fonction ne s'exécute qu'une seule fois

void setup()
{
...; // on définit la broche 4 en entrée
...; // on définit la broche 9 en sortie

Serial.begin(9600); // initialise la vitesse du port série

}

// cette fonction boucle indéfiniment

void loop()
{
int bouton = ...; // lecture BP
int value = ...; // lecture luxmètre
int vitesse = ...; // lecture anémomètre
Serial.println(vitesse); // affichage valeur sur terminal série

if ( ... // détection du seuil de luminosité

... // détection du seuil de vitesse
... ) // détection BP
...; // led allumée
else
...; // led éteinte

delay(10); // stabilisation 10 ms
}

5-TP_arduino.odt 13
 Classe de première STI2D

5. Utilisation de la sortie MLI

5.1. Commande d’un moteur à courant continu
La carte arduino ne peut fournir que 40mA par sortie ce qui peut s'avérer insuffisant ou endommager le matériel si le
moteur provoque un pic d'intensité au démarrage ou en charge.
Pour y remédier, nous utiliserons une interface de puissance dont le rôle sera de faire le lien entre la partie commande,
représentée par la carte Arduino, et la partie puissance : le moteur.
Connecter l'interface à la carte Arduino et au servomoteur
en respectant les branchements comme indiqué ci-dessous.
Côté servomoteur Côté Arduino

1. Réaliser le branchement comme indique sur le schéma ci-dessus.

Broche 2 : TACHY interface
Broche 6 : PWM interface
Broche 5V : +5V interface
Broche GND : GND interface

2. Modifier le programme ci-dessous pour imposer une vitesse au moteur (de 0 à 255).
/*
MLI par interface série
*/

const int MOTEUR = 6; // Digital pin 6 pour commande moteur

char buffer[8] = "";

int i = 0;

/* Routine d'initialisation */
void setup()
{
Serial.begin(...); // Initialisation port COM

5-TP_arduino.odt 14
 Classe de première STI2D

...; // Sortie moteur

}

/* Fonction principale */
void loop()
{
if ( Serial.available() > 0 ) {
char c = Serial.read();

if ( c == '\r' ) {
buffer[i] = 0;
int speed = atoi(buffer);
if ( speed >= 0 && speed <= 255 ) {
analogWrite(...);
Serial.print("vitesse : ");
Serial.println(...);
}
else
Serial.println("valeur incorrecte");
i = 0;
}
else if ( (int) c != -1 )
buffer[i++] = c;
}
}
Pour piloter le moteur en vitesse, respecter les consignes suivantes :
1. Lancer le terminal
2. Cocher Défilement automatique
3. Sélectionner caractère de Retour
4. Sélectionner la bonne vitesse
5. Saisir la vitesse (0 à 255) dans la zone de texte

5-TP_arduino.odt 15
 Classe de première STI2D

5.2. Commande d’un moteur à l'aide d'un potentiomètre

Un potentiomètre est une résistance variable.
1. Modifier le montage précédent pour brancher le potentiomètre comme indiqué ci-dessous :
Broche 2 : TACHY interface
Broche 6 : PWM interface
Broche 5V : +5V interface
Broche GND : GND interface
Broche A0 : module potentiomètre

2. Modifier le programme pour que la vitesse soit imposée par le potentiomètre.

3. Lancer et configurer le terminal pour afficher la vitesse du moteur (nombre de ticks de la roue codeuse de
l'arbre moteur).
/*
MLI par potentiomètre
*/

#include <SimpleTimer.h> // http://arduino.cc/playground/Code/SimpleTimer

const int POTAR = ...; // broche A0 pour potentiomètre

const int MOTEUR = ...; // Digital pin pour commande moteur
const int TACHY = ...; // interruption 0 = pin2 arduino Uno/mega
/*
Board Digital Pins Usable For Interrupts
Uno, Nano, Mini, other 328-based 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
*/

SimpleTimer timer; // Timer pour échantillonnage

unsigned int delai_timer = 100; // Compteur de tick de la codeuse
unsigned int tick_codeuse = 0; // Compteur de tick de la codeuse

/* Routine d'initialisation */
void setup()
{
Serial.begin(...); // Initialisation port COM

...; // Entrée potentiomètre

...; // Sortie moteur

// Interruption sur tick de la codeuse

attachInterrupt(TACHY, compteur, CHANGE);

// Interruption pour affichage vitesse

timer.setInterval(delai_timer, vitesse);
}

/* Fonction principale */
void loop()
{
timer.run();

5-TP_arduino.odt 16
 Classe de première STI2D
// Normalisation et contrôle du moteur
int speed = ...;
if ( speed >= 0 && speed <= 255 )
...;

delay(10);
}

/* Interruption sur tick de la codeuse */

void compteur()
{
// On incrémente le nombre de tick de la codeuse
tick_codeuse++;
}

/* Interruption pour calcul du PID */

void vitesse()
{
int tick = tick_codeuse;
tick_codeuse = 0; // Réinitialisation du nombre de tick de la codeuse

// affichage vitesse moteur

Serial.println(tick);
}

5.3. Programmation d'un moteur

On veut qu'un moteur effectue le cycle suivant :
1. départ arrêté
2. accélération jusqu'à la vitesse maximum sur 1s
3. maintien de la vitesse pendant 2s
4. décélération jusqu'à l'arrêt sur 2s
5. moteur arrêté pendant 1s
6. rebouclage au début
A partir de l'activité 5.1. :
1. Modifier le programme pour obtenir le chronogramme ci-dessus.
2. Faire afficher la vitesse du moteur sur le terminal série.
3. Copier/coller les valeurs de la vitesse mesurée et tracer le graphe associé à l'aide d'un tableur.
4. Vérifier le résultat obtenu avec le cycle du cahier des charges.
/*
programmation moteur DC
*/

#include <SimpleTimer.h> // http://arduino.cc/playground/Code/SimpleTimer

const int POTAR = ...; // broche A0 pour potentiomètre

const int MOTEUR = ...; // Digital pin pour commande moteur
const int TACHY = ...; // interruption 0 = pin2 arduino Uno/mega
/*
Board Digital Pins Usable For Interrupts
Uno, Nano, Mini, other 328-based 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
*/

SimpleTimer timer; // Timer pour échantillonnage

unsigned int delai_timer = 100; // délais échantillonnage
unsigned int tick_codeuse = 0; // Compteur de tick de la codeuse

/* Routine d'initialisation */

5-TP_arduino.odt 17
 Classe de première STI2D
void setup()
{
Serial.begin(...); // Initialisation port COM

...; // Entrée potentiomètre

...; // Sortie moteur

// moteur à l'arrêt
...;

// Interruption sur tick de la codeuse

attachInterrupt(TACHY, compteur, CHANGE);

// Interruption pour affichage vitesse

timer.setInterval(delai_timer, vitesse);
}

/* Fonction principale */
void loop()
{
timer.run();

const int tempo = 10; // 10 ms

// accélération moteur 1s = 1000ms

... acc = 255 * tempo / 1000;
for (float speed(0); speed <= 255; speed += acc) {
...;
delay(tempo);
}

// maintien vitesse 2s
delay(2000);

// décélération moteur 2s = 2000ms

... dec = 255 * tempo / 2000;
for (float speed(255); speed >= 0; speed -= dec) {
...;
delay(tempo);
}

// arrêt 1s
delay(1000);
}

/* Interruption sur tick de la codeuse */

void compteur()
{
// On incrémente le nombre de tick de la codeuse
tick_codeuse++;
}

/* Interruption pour calcul du PID */

void vitesse()
{
int tick = tick_codeuse;
tick_codeuse = 0; // Réinitialisation du nombre de tick de la codeuse

// affichage vitesse moteur

Serial.println(tick);
}

5-TP_arduino.odt 18
 Classe de première STI2D

5.4. Servo moteur

Un servomoteur est un système motorisé capable d'atteindre des positions prédéterminées, puis de les maintenir. La
position est : dans le cas d’un moteur rotatif, une valeur d'angle et, dans le cas d’un moteur linéaire une distance.
On veut commander 2 servo moteurs.
Un premier servo moteur doit effectuer le cycle
ci-contre.
Le deuxième doit être en opposition de phase.

1. Réaliser le montage ci-dessous.

Broche 9 : servo 1
Broche 10 : servo 2

2. Modifier le programme afin de respecter le cahier des charges ci-dessus.

/*
commande servo moteurs
*/

#include <Servo.h>

const int pin_servo1 = ...; // broche 9 servo 1

const int pin_servo2 = ...; // broche 10 servo 2
const int button = ...; // broche 3 pour le bouton poussoir

//Création des objets servo pour les contrôler

Servo servo1, servo2;

void setup()
{
// On connecte les broches aux servos
servo1.attach(pin_servo1);
servo2.attach(pin_servo2);

// initialisation position servo moteurs

initServo();
}

5-TP_arduino.odt 19
 Classe de première STI2D

void loop()
{
if ( ... )
init();
else {
const int tempo = 10; // 10 ms

// position 90° pensant 1s

delay(...);

// accélération servo 2s = 2000ms

... acc = 90 * tempo / 2000;
for (... angle(0); angle <= 90; angle += acc) {
servo1.write(90 ... (int) angle);
servo1.write(90 ... (int) angle);
delay(tempo);
}

// cycle 3
acc = 180 * tempo / 2000;
for (... angle(0); angle <= ...; angle += acc) {
servo1.write(...);
servo1.write(...);
delay(tempo);
}

// cycle 8
acc = 90 * tempo / 1000;
for (... angle(0); angle <= ...; angle += acc) {
servo1.write(...);
servo1.write(...);
delay(tempo);
}
}
}

void initServo()
{
// initialisation positions des servo moteurs à 90°
servo1.write(90);
servo2.write(90);

delay(500); // attente 500ms pour que les servos se mettent en position

}

5-TP_arduino.odt 20
 Classe de première STI2D

6. Afficheur LCD
On souhaite afficher la température et le taux d'humidité contenue dans une pièce sur une afficheur LCD 4.
1. Connecter l'afficheur sur le bus I²C selon le schéma ci-dessous.
Broche A0 : capteur température
Broche A2 : capteur humidité
Bus I²C : LCD

2. Détecter l'adresse utilisée par l'afficheur LCD à l'aide du programme ci-dessous :

//
// scanner I2C
//

#include <Wire.h>

void setup()
{
Wire.begin();

Serial.begin(9600);
while ( !Serial); // Leonardo: wait for serial monitor
Serial.println("\nI2C Scanner");
}

void loop()
{
Serial.println("Scanning...");

int nDevices(0);
for (int address(1); address < 127; address++) {
// The i2c_scanner uses the return value of
// the Write.endTransmisstion to see if
// a device did acknowledge to the address.
Wire.beginTransmission(address);
int error = Wire.endTransmission();

if ( error == 0 ) {
Serial.print("dispositif I2C détecté à l'adresse : 0x");
if ( address < 16 )
Serial.print("0");
Serial.println(address,HEX);

nDevices++;

4 Liquid Crystal Display

5-TP_arduino.odt 21
 Classe de première STI2D
}
}

if ( nDevices == 0 )
Serial.println("Aucun dispositif I2C trouvé\n");
else
Serial.println("terminée\n");

delay(5000); // wait 5 seconds for next scan

}

3. Modifier le programme pour que les mesures soient affichées sur 2 lignes (t° puis% humidité) et rafraîchies
toutes les secondes.
/*
Mesure t° et humidité
*/

#include <wire.h>
#include <LiquidCrystal_I2C.h> // https://bitbucket.org/fmalpartida/new-
liquidcrystal/downloads

const int TEMP = ...; // capteur t° sur broche A0

const int HUMID = ...; // capteur humidité sur broche A2

const int I2C_ADDR = ...; // adresse I2C du LCD

// initialisation de l'objet LCD

LiquidCrystal_I2C lcd(I2C_ADDR);

void setup()
{
lcd.begin(16, 2); // initialise le lcd à 16 chars 2 lignes

// ------- 3 clignotements -------------

for(int i(0); i < 3; i++) {
lcd.backlight();
delay(250);

lcd.noBacklight();
delay(250);
}

lcd.backlight(); // rétro éclairage on

}

void loop()
{
// clear the screen
lcd.clear();

//-------- Write characters on the display ------------------

// NOTE: Cursor Position: (CHAR, LINE) start at 0
lcd.setCursor(0, 0); //Start at character 4 on line 0
lcd.print("Temp : ");
... t = (... * 500) / 1024;
lcd.print(t);
lcd.print("°C");

lcd.setCursor(0, 1);
lcd.print("Hum : ");
... h = ...;
lcd.print(h);
lcd.print("%");

delay(1000);

5-TP_arduino.odt 22
 Classe de première STI2D
}

7. Modules
• Mesure de distance par ultrason
• Infrarouge distance GP2Y0A21
• Diviseur de tension DFR 0051
• Module relais de puissance 24V
• Bouton poussoir
• Infrarouge receiver DFR 0094
• Capteur de température DFR 0023
• Potentiomètre
• Mesure du son
• Buzzer
• 10cm infrared sensor SEN 0024
• Current sensor 30A phjidget
• IR transmitter
• Capteur Capacitif
• Commande moteur
• Capteur d’humidité
• Mesure de luminosité
• roues codeuses
• Écran LCD 4x16
• Écran LCD 2x16
• Centrale inertielle 6DOF
• LED
• capteur sensitive

shields
• Relay Shield for Arduino V2.1
• Grove Base Shield
• shield moteur 2A
• shield Xbee
• shield wifi
• shield NFC
• shield I/O V7
• shield I/O V6
• shield GSM
• shield CAN bus
• shield SD card
• shield ethernet
• shield chargeur solaire

5-TP_arduino.odt 23
 Classe de première STI2D

8. Références
• Tutoriel Arduino
• Manuel de référence Aduino
• langage C
• langage C++
• la résistance
• la diode
• le Transistor
• Travaux Pratique Arduino
• Référence Langage Arduino

5-TP_arduino.odt 24