Classe de première STI2D

TP Arduino

Table des matières1. Installation et configuration de la carte Arduino..............................................................................................................2

1.1. Carte Arduino...........................................................................................................................................................21.2. Le shield d'extension E/S.........................................................................................................................................21.3. Structure d’un programme.......................................................................................................................................31.4. Interface de développement.....................................................................................................................................3

2. Utilisation de la sortie numérique.....................................................................................................................................42.1. Clignotement d'une LED..........................................................................................................................................42.2. Clignotement de 2 LED...........................................................................................................................................5

3. Utilisation de l'entrée numérique......................................................................................................................................63.1. Détection d'un Bouton Poussoir...............................................................................................................................6

4. Utilisation de l’entrée analogique.....................................................................................................................................74.1. Mesure de l’éclairement...........................................................................................................................................74.2. Télémétrie................................................................................................................................................................9

4.2.1. Capteur SRF05...........................................................................................................................................................94.2.2. Capteur Ultrasonic Ranger.......................................................................................................................................10

4.3. Simulation store électrique.....................................................................................................................................115. Utilisation de la sortie MLI.............................................................................................................................................14

5.1. Commande d’un moteur à courant continu............................................................................................................145.2. Commande d’un moteur à l'aide d'un potentiomètre.............................................................................................165.3. Programmation d'un moteur...................................................................................................................................175.4. Servo moteur..........................................................................................................................................................19

6. Afficheur LCD................................................................................................................................................................217. Modules..........................................................................................................................................................................23

shields...........................................................................................................................................................................238. 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 unCAN2 avec 10 bits de résolution. Sur la carte, il y a un circuit qui permet de gérer facilement l’USB3 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/SLe 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 etanalogiques. 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érique3 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éveloppementPour 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 LEDOuvrir 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 shieldextension 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 foisvoid setup(){ pinMode(led, OUTPUT); // on définit la broche en sortie}

// cette fonction boucle indéfinimentvoid 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 LED1. 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 LED1Broche 12 : module LED2

/*

clignotement 2 diodes alternées */

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

// cette fonction ne s'exécute qu'une seule foisvoid 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éfinimentvoid 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 Poussoir1. 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 LEDBroche 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 LEDconst int button = 3; // broche 3 pour le bouton poussoir

// the setup function runs once when you press reset or power the boardvoid 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 forevervoid 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’éclairementLe 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 LEDBroche 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 LEDconst int lux = ...; // broche analogique A0 pour le capteur

// cette fonction ne s'exécute qu'une seule foisvoid 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étrieOn veut mesurer une distance par télémétrie à ultrason.

4.2.1. Capteur SRF05Le 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 : TriggerBroche 7 : EchoBroche 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 LEDconst int emetteur = ...; // broche 7 pour envoi signalconst 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 Ranger1. 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 LEDconst 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 électriqueOn 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 enbuté (BP).

1. Réaliser le schéma de montage ci-dessous :

Broche 4 : module BPBroche 9 : module LEDBroche 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 BPconst int led = ...; // broche 9 pour la LEDconst int lux = ...; // broche analogique A0 pour le capteur

// cette fonction ne s'exécute qu'une seule foisvoid 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éfinimentvoid 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 BPBroche 9 : module LEDBroche 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 BPconst int led = ...; // broche 9 pour la LEDconst int lux = ...; // broche analogique A0 pour le luxmètreconst int vent = ...; // broche analogique A3 pour le potentiomètre

// cette fonction ne s'exécute qu'une seule foisvoid 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éfinimentvoid 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 continuLa 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 interfaceBroche 6 : PWM interfaceBroche 5V : +5V interfaceBroche 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 terminal2. Cocher Défilement automatique3. Sélectionner caractère de Retour4. Sélectionner la bonne vitesse5. 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ètreUn 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 interfaceBroche 6 : PWM interfaceBroche 5V : +5V interfaceBroche GND : GND interfaceBroche 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ètreconst int MOTEUR = ...; // Digital pin pour commande moteurconst int TACHY = ...; // interruption 0 = pin2 arduino Uno/mega/*Board Digital Pins Usable For InterruptsUno, Nano, Mini, other 328-based 2, 3Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21*/

SimpleTimer timer; // Timer pour échantillonnageunsigned int delai_timer = 100; // Compteur de tick de la codeuseunsigned 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 moteurOn 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ètreconst int MOTEUR = ...; // Digital pin pour commande moteurconst int TACHY = ...; // interruption 0 = pin2 arduino Uno/mega/*Board Digital Pins Usable For InterruptsUno, Nano, Mini, other 328-based 2, 3Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21*/

SimpleTimer timer; // Timer pour échantillonnageunsigned int delai_timer = 100; // délais échantillonnageunsigned 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 moteurUn 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 1Broche 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 1const int pin_servo2 = ...; // broche 10 servo 2const int button = ...; // broche 3 pour le bouton poussoir

//Création des objets servo pour les contrôlerServo 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 LCDOn souhaite afficher la température et le taux d'humidité contenue dans une pièce sur une afficheur LCD4.

1. Connecter l'afficheur sur le bus I²C selon le schéma ci-dessous.

Broche A0 : capteur températureBroche 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 A0const int HUMID = ...; // capteur humidité sur broche A2

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

// initialisation de l'objet LCDLiquidCrystal_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