Vous êtes sur la page 1sur 9

TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

CHAPITRE 5 : COMMANDE DES PROCESSUS AVEC ARDUINO

1. Découverte du système Arduino


1.1. Découverte de la carte Arduino
La carte Arduino Uno que nous allons utiliser est une sorte de petit ordinateur. Il
possède un microcontrôleur (microprocesseur + mémoire+ interface de gestion des
entrées/sorties).

1.2. Premiers programmes


1.2.1. Structure d'un programme Arduino:

La structure de base d'un programme Arduino (sketch) :

variables (déclaration des variables)

void setup()
{
Commandes d'initialisation (entrées, sorties, ...)
}
void loop()
{
Instructions ;
}

©2020 0
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

1.2.2. Les premiers programmes simples


1.2.2.1. Programme N°1 : clignotement d'une LED

Après avoir lancé le logiciel Arduino : écrivez (ou copiez) le programme (sketch)
suivant en respectant très exactement la mise en page :

/* début du programme
Nom : Cligno_LED13
Fonctionnement : Commande sans arrêt le clignotement d'une
LED.
Les temps ON (active ou allumée) et OFF (inactive ou éteinte)
sont identiques : 0.1s. La LED celle connectée sur la broche
13.
*/

void setup()
{
pinMode(13, OUTPUT); // la broche 13 est définie en
sortie.
}

void loop()
{
digitalWrite(13, HIGH); // allume la LED
delay(100); // attend, en ms, le temps indiqué entre
parenthèses
digitalWrite(13, LOW); // éteint la LED
delay(100); // attend, en ms, le temps indiqué entre
parenthèse
}
//fin du programme//

Ce programme fait clignoter la LED du module Arduino toutes les 0.2 seconde (ON-OFF).
L'expression ON-OFF représente la période. Ici la durée ON est égale à la durée OFF (0,1 s).

pinMode ( n° de broche, [OUTPUT ou INPUT] ) ; Déclare la broche « n° de broche » en


entrée ou en sortie. Cela ne concerne que les entrées numériques (appelées aussi Tout Ou
Rien. En anglais : digital).

digitalWrite ( n° de broche, [HIGH ou LOW] ) met un niveau haut (1) ou bas (0) sur la
broche désignée. Il s'agit bien d'une sortie logique appelée aussi TOR (Tout Ou Rien) ou
digital (en anglais).

delay (100) : le microcontrôleur de la carte Arduino attend 100 millisecondes.

Sauvegardez ce programme sous le nom : TP0_LED_clignote

©2020 1
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

Pour la simulation sur ISISle fichier .Hex se trouve à l’adresse suivante :


C:\Users\hp\AppData\Local\Temp\arduino_build_852496

TP0 : Cligonetement des LEDs

a) Faire clignoter 3 LEDs placer dur les IO11, IO12 et IO13


b) Faire allumer et éteindre respectivement les trois LEDS précédentes les unes
après les autres

2. Les variables
2.1. Quelques notions sur les variables
En informatique on a l'habitude d'utiliser des variables que l'on affecte aux valeurs que
l'on veut et que l'on peut même modifier tout au long d'un programme. Ces variables sont des
symboles qui associent un nom (l'identifiant) à une valeur. Ces variables sont définies en tête
de programme (on choisit obligatoirement leur type et on peut aussi leur donner une valeur.
Cette valeur peut être ensuite modifiée dans le programme).
On va utiliser la variable de type int : int est l'abréviation d'integer (nombre entier).
Placé devant le nom de la variable, il indique que celle-ci est un nombre entier sur 16 bits.
Exemple :
int durée = 5 ; // l’ordinateur doit réserver une case mémoire « temps » auquel il
associe le valeur 5.
si dans le programme il y a ça :
durée = durée + 2 ; alors la variable « durée » change : durée=7
si plus loin dans le programme il y a ça :
durée = durée*3 ; alors la variable « durée » change : durée =21

TP1 : Déclarer une variable du type entier, nommée durée , avec pour valeur 10 et
utiliser la pour la temporisation du programme précédant.

2.1.1. Les fausses variables d'arduino : #define


On va aussi utiliser la fonction « #define ». Celle-ci, bien que moins intéressante que
la définition précédente, est très utilisée. Elle ne définit pas la variable, mais simplement, lors
de la compilation, elle remplace le nom de la variable par la valeur écrite à côté.
Ainsi dans notre programme, #define LED 13 signifie que chaque fois que le mot LED
apparait dans le programme, celui-ci sera remplacé par 13. Cette valeur ne peut jamais être
changée dans le programme.

©2020 2
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

TP3 : Dans le programme précédent, utiliser le #define pour remplacer chaque pin par
LED1 ,LED2 et LED3.

2.2. Quelques types de variables


Types Nature Valeur de donnée
Char Caractères alphabétiques de ' a à z ' +128 à 127
Int Nombre entier pouvant exploiter les valeurs négatives -32 768 à 32 767
Float Nombre à virgule pouvant exploiter les valeurs négatives -3.4*10-38 à 3.4*1038
long Chiffre entier de grande « taille » 0 à 4 294 967 295
boolean 1 ou 0, true ou false, HIGH ou LOW. 0 et 1
string Chaine de caractères "mots complets"

3. Lecture de l’état d’une broche d’entrée numérique


La lecture d’un pin permet de connaitre l’état de ce pin (0 ou 1) ; elle s’effectue avec
la commande « digitalRead() »
Synthaxe
Val=digitalRead(pin) ; Val est une variable de type entier , et pin le numéro du pin
NB : le pin doit être au préalable configuré en entrée (pinMode(13, INPUT)

TP3 : Montage simple allumage


L’interupteur est relier au pin OI10 et la lampe au pin OI12
#define LAMP 12
#define K 10
int ValK ; // variable pour stoker l'état de linterrupteur
void setup()
{
pinMode(LAMP, OUTPUT); // la broche 12 (representant la lampe) est définie en
sortie.
pinMode(K, OUTPUT);// la broche 10 (correspondant à l'intérupteur K) est définie en
entrée.
}
void loop()
{
ValK = digitalRead(K); // Lire l'état de du pin 10

if (ValK==1)
{
digitalWrite(LAMP, HIGH); // on allume la lampe
}
else
{
digitalWrite(LAMP, LOW); // éteint la Lampe
}
}
TP4 : Ecrivez le programme d’une minuterie

©2020 3
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

TP5 : Ecrivez le programme d’un télérupteur


4. Communication par la liaison série
Du côté de l'ordinateur, l'environnement de développement Arduino propose de base un

outil pour communiquer. Pour cela, il suffit de cliquer sur le bouton.

le terminal série
Dans cette fenêtre, vous allez pouvoir envoyer et recevoir des messages sur la liaison série de
votre ordinateur (qui est émulée par l'Arduino).
Du côté du programme, pour utiliser la liaison série et communiquer avec l'ordinateur, on
utilise un objet qui est intégré nativement dans l'ensemble Arduino : l'objet Serial.
Cet objet rassemble des informations (vitesse, bits de données, etc.) et des fonctions (envoi,
lecture de réception...) sur ce qu'est une voie série pour Arduino.
Pour commencer, il faut initialiser l'objet Serial afin de définir la vitesse de communication
entre l'ordinateur et la carte Arduino grâce à la fonction begin(). Cette vitesse doit être
identique côté ordinateur et côté programme.
Exemple : Serial.begin(9600); //établissement d'une communication série à 9600 bauds

4.1. Envoi de données


La fonction print() permet d'envoyer des caractères.
Le programme ci-dessous envoi l'ensemble des lettres de l'alphabet.

TP6 : Copier et compiler le programme ci-dessous


void setup()
{
Serial.begin(9600); //établissement d'une communication série à 9600 bauds
}
void loop()
{

©2020 4
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

char i = 0;
char lettre = 'a'; // ou 'A' pour envoyer en majuscule
Serial.println("------ L'alphabet ------"); //petit message d'accueil
//on commence les envois
for (i=0; i<26; i++)
{
Serial.print(lettre); //on envoie la lettre
lettre = lettre + 1; //on passe à la lettre suivante
delay(250); //on attend 250ms avant de réenvoyer
}
Serial.println(""); //on fait un retour à la ligne
delay(2000); //on attend 2 secondes avant de renvoyer l'alphabet
}

4.2. Réception des données


Pour vérifier si on a reçu des données, on va régulièrement interroger la carte pour lui
demander si des données sont disponibles dans son buffer de réception. Un buffer est une
zone mémoire permettant de stocker des données sur un court instant. Cette mémoire est
dédiée à la réception sur la voie série. Il en existe un aussi pour l'envoi de donnée, qui met à la
queue leu leu les données à envoyer et les envoie dès que possible. En résumé, un buffer est
une sorte de salle d'attente pour les données.
Pour vérifier si des données sont arrivées, on utilise la fonction available() (de
l'anglais "disponible") de l'objet Serial. Cette fonction renvoie le nombre de caractères dans le
buffer de réception de la liaison série ou -1 quand il n'y a rien à lire sur le buffer de réception.
Une fois que l'on sait qu'il y a des données, il faut aller les lire. La lecture se fera tout
simplement avec la fonction... read() !
Cette fonction renverra le premier caractère arrivé non traité. On accède donc caractère
par caractère aux données reçues. Si jamais rien n'est à lire, la fonction renverra -1 pour le
signaler.

TP7. Réception et lecture d’un caractère par voie série


Le programme ci-dessous revoie par voie série la touche saisie au clavier.
Recopier et tester ce programme
char saisie; // caractère lu sur la voie série
void setup()
{
Serial.begin(9600); //démarre une nouvelle liaison série à 9600bauds
}
void loop()
{
//on commence par vérifier si un caractère est disponible dans le buffer
if ( Serial.available() > 0 )
{

©2020 5
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

saisie = Serial.read(); //lecture du premier caractère disponible


Serial.println(""); //aller a la ligne
Serial.print("- La touche est: "); //message
Serial.write(saisie);
}
}

TP 8 : A partir tu TP5 (Télérrupteur), écrire un programme qui commande trois lampes


L1,L2,L3, à partir des touches du clavier 1 , 2 et 3.

5. Les entrées analogiques


La carte Arduino dispose d'un CAN 10 bits pour une tension analogique de 0 à +5V.
La fonction analogRead() permet de lire la valeur lue sur une entrée analogique de
l'Arduino. Elle prend un argument et retourne la valeur lue :
• L'argument est le numéro de l'entrée analogique (pin) à lire
• La valeur retournée (un int) sera le résultat de la conversion analogique->numérique
Sur une carte Arduino Uno, on retrouve 6 CAN. Ils se trouvent tous du même côté de la carte,
là où est écrit "Analog IN" :
Ces 6 entrées analogiques sont numérotées, tout comme les entrées/sorties logiques. Par
exemple, pour aller lire la valeur en sortie d'un capteur branché sur le convertisseur de la
broche analogique numéro 3, on fera :
valeur = analogRead(3);
La valeur retournée par la fonction est comprise entre 0 et 1023 pour une tension de 0 à
+5V, soit 5/1024 =4,88 mV par bit.

TP 9 : Convertisseur analogique numérique


Dans ISIS, relier un potentiomètre sur la broche A0 de l’Arduino et un HyperTerminal sur la
voie série
Une fois le raccordement fait, tester ce petit programme qui va effectuer une mesure de la
tension obtenue sur le potentiomètre, puis envoi la valeur lue sur la liaison série :
const int potar = A0; // le potentiomètre, branché sur la broche analogique 0
int valeurLue; //variable pour stocker la valeur lue après conversion
float tension; //variavle pour convertir cette valeur en une tension
void setup()
{
//on se contente de démarrer la liaison série
Serial.begin(9600);
}
void loop()
{
valeurLue = analogRead(potar);//on convertit en nombre binaire la tension lue en
//sortie du potentiomètre

©2020 6
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

tension = valeurLue * 5.0 / 1024;//on traduit la valeur brute en tension


//on affiche la valeur lue sur la liaison série
Serial.println("");
Serial.print("tension = ");
Serial.print(tension);
delay(500);
}

TP 10: Utilisation du capteur de température LM35


A partir du capteur de température LM35 disponible dans ISIS , écrivez un programme
qui mesure en temps réel la température ambiante et renvoie le résultat sur la voie série de
l’Arduino.

6. L’afficheur LCD
Il existe un driver "LCD" pour ce type d'afficheur. Ce composant va servir à décoder un
ensemble "simple" de bits pour afficher un caractère à une position précise ou exécuter des
commandes comme déplacer le curseur par exemple.
6.1. Brochage du LCD

6.2. Connection du LCD avec l’Arduino

©2020 7
M.GNETCHEJO
TP COMMANDE PAR ORDINATEUR DES PROCEDES INDUSTRIELS MASTER 2

6.3. Afficher du texte


Une ligne #include "LiquidCrystal.h" doit apparaitre en haut de la page de code.
Ensuite, il reste à dire à la carte Arduino où est branché l'écran (sur quelles broches) et quelle
est la taille de ce dernier (nombre de lignes et de colonnes). Il faudra commencer par déclarer
un objet lcd, de type LiquidCrystal et qui sera global à notre projet.

TP 11 : Utilisation du LCD
#include <LiquidCrystal.h> // ajout de la librairie
const int RS=8,EN=9,D4=10,D5=11,D6=12,D7=7; // configuration des broches du LCD
LiquidCrystal lcd(RS,EN,D4,D5,D6,D7); //liaison 4 bits de données
void setup()
{
lcd.begin(16,2); // utilisation d'un écran 16 colonnes et 2 lignes
}
void loop() {
lcd.setCursor(2,0);
lcd.print("PROGRAMME TEST"); // petit test pour vérifier que tout marche

lcd.setCursor(5,1); // utilisation d'un écran 16 colonnes et 2 lignes


lcd.print("DU LCD"); // petit test pour vérifier que tout marche
}

©2020 8
M.GNETCHEJO

Vous aimerez peut-être aussi