TP 1

Cette présentation est inspirée des sites :

Flossmanuals
arduino.cc/reference/fr/ : référence du langage Arduino en français

Débuter avec Arduino

Pour débuter ouvrons avec l'IDE Arduino le programme exemple Blink :

Lorsque vous-êtes bloqué pour commencer à écrire un programme, pensez à ouvrir un programme exemple correspondant à votre projet.

Un programme Arduino comporte trois parties :

/*
  Blink
  Allume la LED une seconde puis l'éteint une seconde. Puis recommence...
  
  En gris, apparaissent les commentaires qui ne seront pas exécutés dans le programme
  // pour une ligne de commentaire
  /* Pour un intervalle
  de commentaires  
*/

/* 1) Zone 1 : la partie déclaration des variables (optionnelle) */
int led=13; // sélection de la broche (pin) sur laquelle est connectée la LED

/* 2) Zone 2 : la partie initialisation et configuration des entrées/sorties : la fonction setup ()*/
void setup() {
  pinMode(led, OUTPUT); // broche de la led configurée en sortie
}

/* 3) Zone 3 : la partie principale qui s'exécute en boucle : la fonction loop () */
void loop() {
  digitalWrite(led, HIGH);   // allume la led (HIGH correspond à 5V)
  delay(1000);              // attendre une seconde = 1000 ms
  digitalWrite(led, LOW);    // éteint la led (LOW correpond à 0 V)
  delay(1000);              // attendre une seconde 
}

Q1) Téléverser ce programme, et testez-le.
Modifier le programme pour obtenir un clignotement impulsionnel : 200 ms allumé puis 800 ms éteint.

Attention : par défaut l'IDE sélectionne le COM1 pour communiquer avec l'Arduino.
En réalité l'Arduino est sur un COM différent et supérieur à 1.
Il faut sélectionner sur Outils/Port/COMxx à la place de COM1.
Après cette sélection l'IDE pourra communiquer avec l'Arduino.

Coloration syntaxique

Lorsque du code est écrit dans l'interface de programmation, certains mots apparaissent en différentes couleurs qui clarifient le statut des différents éléments :

En orange, apparaissent les mots-clés reconnus par le langage Arduino comme des fonctions existantes. Lorsqu'on sélectionne un mot coloré en orange et qu'on effectue un clic avec le bouton droit de la souris, l'on a la possibilité de choisir « Find in reference » : cette commande ouvre directement la documentation de la fonction sélectionnée. Une version française de l'aide est disponible sur mon-club-elec.fr

En bleu, apparaissent les mots-clés reconnus par le langage Arduino comme des constantes.

En gris, apparaissent les commentaires qui ne seront pas exécutés dans le programme. Il est utile de bien commenter son code pour s'y retrouver facilement ou pour le transmettre à d'autres personnes. L'on peut déclarer un commentaire de deux manières différentes :

dans une ligne de code, tout ce qui se trouve après « // » sera un commentaire.
l'on peut encadrer des commentaires sur plusieurs lignes entre « /* » et « */ ».

La syntaxe du langage

ponctuation

Le code est structuré par une ponctuation stricte :

toute ligne de code se termine par un point-virgule « ; »
le contenu d'une fonction est délimité par des accolades « { » et « } »
les paramètres d'une fonction sont contenus pas des parenthèses « ( » et « ) ».

Une erreur fréquente consiste à oublier un de ces éléments.

Les variables

Une variable est un espace réservé dans la mémoire de l'ordinateur. C'est comme un compartiment dont la taille n'est adéquate que pour un seul type d'information. Elle est caractérisée par un nom qui permet d'y accéder facilement.

Il existe différents types de variables identifiés par un mot-clé dont les principaux sont :

nombres entiers (int)
nombres à virgule flottante (float)
texte (String)
valeurs vrai/faux (boolean).

Les fonctions

Une fonction (également désignée sous le nom de procédure ou de sous-routine) est un bloc d'instructions que l'on peut appeler à tout endroit du programme.

Le langage Arduino est constitué d'un certain nombre de fonctions, par exemple analogRead(), digitalWrite() ou delay().

L'aide (clic droit sur un mot orange) est disponible pour l'utilisation de toutes les fonctions, une version française est disponible sur le site mon-club-elec.fr.

Il est possible de déclarer ses propres fonctions par exemple :

void clignote_lent(){
    digitalWrite (brocheLED,  HIGH) ;
    delay (1000) ;
    digitalWrite (brocheLED,  LOW) ;
    delay (1000) ;
}

Pour exécuter cette fonction, il suffit de taper la commande :

clignote_lent();

Les structures de contrôle

Les structures de contrôle sont des blocs d'instructions qui s'exécutent en fonction du respect d'un certain nombre de conditions.

Il existe plusieurs types de structure :

1) if...else : exécute un code si certaines conditions sont remplies et éventuellement exécutera un autre code avec sinon.

if (uneVariable > 50) { // début du bloc d'instructions à éxécuter
// faire quelque chose
} // fin du bloc d'instructions à éxécuter

exemple avec deux si sinon emboités :

// Si T < 27 Led clignote lentement (1000 ms)
// Si 27 ≤ T ≤ 30 led allumée et ne clignote pas
// Si T > 30 Led clignote rapidement (200 ms)
  if (T<27) {clingote_lent();}
    else { // Début else 1
           if(T<30){digitalWrite(led,HIGH);}
              else {clingote_rapide();}
         } // Fin else 1

Autre façon de coder la même chose, en utilisant l'opérateur logique et : &&

(27 <= T && T <=30) <=> 27 ≤ T et T ≤ 30 <=> 27 ≤ T ≤ 30

if (T<27) clingote_lent(); // Si T < 27 Led clignote lentement (1000 ms)
if (27 <= T && T <=30) digitalWrite(led,HIGH); // Si 27 ≤ T ≤ 30 led allumée et ne clignote pas
if (T>30) clingote_rapide(); // Si T > 30 Led clignote rapidement (200 ms)

Remarque : lorsqu'il n'y a qu'une instruction à coder après un if , on peut "oublier" de mettre les accolades...

2) for : exécute un code pour un certain nombre de fois.

for (initialisation; condition; incrementation) { // initialisation : i=0; condition : i<n; incrémentation : i++
//instruction(s) à exécuter n fois;
}

Incrémentation : i++ <=> i=i+1

// Joue 61 notes : du La1 au La6 sur un Piezo
float f=55; // fréquence du La1
// pour i de 0 à 60, par pas de 1 soit 61 valeurs
for (int i=0; i < 61; i++){
    tone(piezo,int(f));  // Joue la note calculée sur un Piezo (partie entière)
    f=f*1.05946;   // calcul la note suivante
    delay(300);    // la note est jouée durant 300 ms avant de passer à la suivante
}

Pourquoi 61 notes : 5 octaves = 5*12 = 60 notes + le La6 soit 61 notes

3) while : exécute un code tant que certaines conditions sont remplies

while(expression) { // tant que l'expression est vraie
// instructions à effectuer
}

// Joue toutes les notes du Do-1 au Do7 sur un Piezo
float f=32.7; // fréquence du Do-1 (une octave en dessous du Do1)
// le Do7 a pour fréquence 4186 Hz
while (f<4186) {
    tone(piezo,int(f));  // Joue la note calculée sur un Piezo (partie entière)
    f=f*1.05946;   // calcul la note suivante
    delay(300);    // la note est jouée durant 300 ms avant de passer à la suivante
}

Faites vos gammes

Q2a) Réaliser un programme qui joue toutes les notes en montant du Do2=130,813 Hz au Do6 = 2093 Hz
Attendre 5 secondes avant de recommencer
Brancher le piezo entre la masse et la patte piezo=7

Monter d'une note revient à multiplier la fréquence de la note précédente par = 1.05946.
Au bout de 12 notes on multiplie par 2 la fréquence : il s'agit d'une octave.

Vous avez du mal à commencer ?
Arduino pour les nuls : affiche la structure du programme avec des commentaires.
Toujours en difficulté ? Le corrigé.

Vous pouvez vérifier la fiabilité de votre programme en comparant avec la fréquence des notes sur Wikipédia.

Q2b) On souhaite faire varier la vitesse d'éxécution des notes, pour cela :
- ajouter un potentiomètre sur l'entrée A0 (voir le montage du paragraphe ci-dessous Réalisation d'un voltmètre )
- lire la valeur de ce potentiomètre (qui varie entre 0 et 1023) avec la fonction analogRead(A0)
- puis la diviser par deux et placer le résultat dans la fonction delay à la place de 300 ms.

a = analogRead(A0)/2;
delay(a);

Q3) Ajouter le code pour jouer toutes les notes en descendant du Do6 vers le Do2.

Descendre d'une note revient à diviser la fréquence de la note précédente par

Mesurer une tension avec un Arduino

Les entrées analogiques A0 à A5

Par défaut et contrairement aux entrées/sorties numériques qui ne peuvent prendre que deux états HAUT et BAS, ces six entrées peuvent admettre toute tension analogique comprise entre 0 et 5 Volts.

Pour pouvoir être traitées par le microcontrôleur, ces entrées analogiques sont prises en charge par un CAN (Convertisseur Analogique Numérique ou ADC pour Analog Digital Converter) dont le rôle est de convertir l'échantillon de tension V_E en une grandeur numérique binaire sur n bits.

Le convertisseur de la carte Arduino Uno possède une résolution de 10 bits, soit 2¹⁰= 1024 possibilités de 0 à 1023.
La tension de référence par défaut est de 5 V avec une alimentation extérieure, en auto alimentation USB légèrement moins (environ 4,8 V).

Q4a) Ainsi, pour n=10 bits et la tension de référence par défaut Vref=5 Volts.
Le quantum, ou LSB (pour Least Significant Bit, le bit de poids faible) ou la résolution vaut :

Q4b) lorsque nous sommes branché uniquement en USB la tension de référence est légèrement inférieure à 5 V , calculer le quantum si Vref = 4,82 V

Q4c) Si l’entrée analogique A0 transmet n = 780 on détermine la tension V_E en Volt ainsi :

La fonction analogRead(broche_analogique)

Paramètre : broche_analogique : le numéro de la broche analogique sur laquelle il faut convertir la tension analogique appliquée (0 à 5 ou A0 à A5)
Valeur renvoyée : valeur int (0 to 1023) correspondant au résultat de la mesure effectuée

C'est à l'utilisateur de calculer la tension correspondante en volt : v = 4.82/1024*analogRead(A0) ;

Réalisation d'un voltmètre

Nous aurons souvent besoin de mesurer la tension à la sortie d'un capteur analogique.

Montage d'un potentiomètre en diviseur de tension :

Patte de gauche : 5V
Patte du milieu : A0 (entrée analogique Arduino)
Patte de droite : 0 V (GND : ground, masse)

Attention ne pas mettre 0V ou 5V sur la patte du milieu : risque de court circuit !
Vos prédécesseurs ont fait souffrir les potentiomètres, en cas de problème remplacez-le par un générateur variable 0 - 5 V

Si vous alimentez un Arduino par cordon USB uniquement, le 5 V n'est pas à 5 V : mesurez-le.

Si vous mesurez Vréf = 4,82 V remplacez 5,00 par cette valeur.

Afficher la tension mesurée sur le moniteur série

Q5) Réaliser un programme affichant sur le moniteur série la tension mesurée sur la patte A0
Vérifier la fiabilité de votre mesure à l'aide d'un voltmètre.

Faites un tableau de 5 mesures.

Vous avez du mal à commencer ?
Arduino pour les nuls : affiche la structure du programme avec des commentaires.
Toujours en difficulté ? Le corrigé.

Q6) Alarme lumineuse : ajouter une LED sur la sortie numérique 9 et modifier votre programme pour que

la LED soit allumée si V < 3 V
la LED soit éteinte si 3 ≤ V ≤ 3.5 V
la LED clignote rapidement si V > 3.5 V

Vous avez du mal à commencer ?
Arduino pour les nuls : affiche la structure du programme avec des commentaires.
Toujours en difficulté ? Le corrigé.

Vous avez fini ? Faites un son et lumière !

Si vous avez fini, vous pouvez reprendre le montage piezo de la question 3.

Q3b) Profitez des 2 LED disponibles sur le protoshield pour faire un son et lumière.
Exemple : si le numéro n de la note jouée est pair, on allume la LED 2 et on éteint la LED 1
si le numéro n de la note jouée est impair, on allume la LED 1 et on éteint la LED 2

Autre possibilité : cabler une LED RGB et changer la couleur de la LED à chaque note jouée

D'autres idées ? Testez-les !

Une fonction bien utile : la fonction modulo %

% (modulo) :         Calcule le reste de la division d'un entier par un autre
Syntaxe :               dividende % diviseur
Paramètres :        dividende : le nombre à diviser (le numérateur)
                               diviseur : le nombre qui divise (le dénominateur)
Valeur renvoyée : le reste de la division

30%2            // vaut 0 (30/2 = 15 reste 0)
39%2            // vaut 1 (39/2 = 19 reste 1)
n%2              // vaut 0 si n est pair, vaut 1 si n est impair
Opérateurs logiques de comparaison x est égal à y : x==y
n%2==0       // renvoie vrai si n est pair, faux si n est impair

if (n%2==0) {  // Si n est pair
  ... // Allumer LED2
  ... // Eteindre LED1
  } // fin de Si