Nous allons ici construire une station météo à l'aide d'un microcontrôleur arduino. Son utilisation nous permettra d'obtenir plusieurs grandeurs comme la température ,la pression,... que nous pourons analyser et traîter.

La réalisation de cette station ne demande pas de notions de programmation, tout est détaillé.

Au programme:

Le document à compléter est téléchargeable ici

Code de déblocage du chapitre :

Installation

Installation du logiciel

Pour télécharger le logiciel, il faut se rendre sur : https://arduino.cc/en/Main/Software puis télécharger la dernière version stable en fonction de votre système d’exploitation.

Interface du logiciel

Lançez le logiciel en double­ cliquant sur l’icône avec le symbole « infini » en vert. C’est l’exécutable du logiciel. Après un léger temps de réflexion, une image s’affiche :

Cette fois, après quelques secondes, le logiciel s’ouvre. Une fenêtre se présente à vous :

Approche et utilisation du logiciel

Attaquons-nous plus sérieusement à l’utilisation du logiciel. La barre des menus est entourée en rouge et numérotée par le chiffre 1.

Le menu Fichier

Quelques menus intéressants :

Les boutons

Vous êtes désormais prêt pour passer à la carte arduino

Présentation de la carte

Pour commencer la découverte de la carte Arduino, présentons la carte en elle-même: comment s’en servir et avec quoi? Sur cette photo les points importants de la carte sont notifiés en rouge.

Constitution de la carte

Voyons quels sont ces points importants et à quoi ils servent.

<

Installation de la carte

Afin d’utiliser la carte, il faut l’installer. Normalement, les drivers sont déjà installés sous GNU/Linux. Sous mac, il suffit de double cliquer sur le fichier .mkpg inclus dans le téléchargement de l’application Arduino et l’installation des drivers s’exécute de façon automatique.

Sous Windows

Lorsque vous connectez la carte à votre ordinateur sur le port USB, un petit message en bas de l’écran apparaît. Théoriquement, la carte que vous utilisez doit s’installer toute seule( Win 10 et supérieur). Cependant, si vous êtes sous Win 7, il se peut que ça ne fonctionne pas du premier coup. Dans ce cas, laissez la carte branchée puis allez dans le panneau de configuration. Une fois là, cliquez sur “système” puis dans le panneau de gauche sélectionnez “gestionnaire de périphériques”. Une fois ce menu ouvert, vous devriez voir un composant avec un panneau “attention” jaune. Faites un clic droit sur le composant et cliquez sur “Mettre à jour les pilotes”. Dans le nouveau menu, sélectionnez l’option “Rechercher le pilote moi-­même”. Enfin, il ne vous reste plus qu’à aller sélectionner le bon dossier contenant le driver. Il se trouve dans le dossier d’Arduino que vous avez dû décompresser un peu plus tôt, et se nomme “drivers” (attention, ne descendez pas jusqu’au dossier “FTDI”). Par exemple, en Win7, le chemin sera :
C:\Program Files (x86)\Arduino\drivers

Après l’installation et une suite de clignotements sur les micro­LED de la carte, celle-­ci devrait être fonctionnelle; une petite LED verte témoigne de la bonne alimentation de la carte :

Test de la carte

Ne commencez pas à programmer tête baissée: il faut, avant toutes choses, tester le bon fonctionnement de la carte: Car ce serait idiot de programmer la carte et de chercher d'éventuelles erreurs dans le programme alors que le problème viendrait de la carte ! Il faut donc tester le matériel en chargeant un programme.

1ère étape : ouvrir un programme

Nous allons choisir un exemple tout simple qui consiste à faire clignoter une LED. Son nom est Blink et vous le trouverez dans la catégorie Basics :

Une fois que vous avez cliqué sur Blink, une nouvelle fenêtre va apparaître. Elle contient le programme Blink. Vous pouvez alors fermer l’ancienne fenêtre.

2ème étape : choix de la carte et du port

Avant d’envoyer le programme Blink vers la carte, il faut dire au logiciel quel est le nom de la carte et sur quel port elle est branchée.

Choisir la carte que l'on va programmer et son port de connexion

Ce n’est pas très compliqué, le nom de votre carte est indiqué sur elle. Pour nous, il s’agit de la carte "Uno". Cliquer sur "Sélectionner une carte" puis "Sélectionner une autre carte et un autre port".

Dans la nouvelle fenêtre, rechercher "arduino Uno" et sélectionner le port de connexion. Ne choisissez pas COM1 car il n’est quasiment jamais connecté à la carte. Dans le cas présenté ici, il s’agit de COM12

Je ne connais pas mon port

Pour trouver le port de connexion de la carte, vous pouvez aller dans le gestionnaire de périphérique de windows, qui se trouve dans le panneau de configuration. Regardez à la ligne Ports (COM et LPT) et là, vous devriez avoir Arduino Uno (COMX).

Dernière étape

Maintenant, il va falloir envoyer le programme dans la carte. Pour ce faire, il suffit de cliquer sur le bouton Téléverser.

Vous verrez tout d’abord le message “Compilation du croquis en cours…” pour vous informer que le programme est en train d’être compilé en langage machine avant d’être envoyé.

En bas dans l’image, vous voyez le texte : “Téléversement…“, cela signifie que le logiciel est en train d’envoyer le programme dans la carte.

Le message : “Téléversement fait” signale que le programme à bien été chargé dans la carte. Si votre matériel fonctionne, vous devriez avoir une LED sur la carte qui clignote :

Si vous n’obtenez pas ce message mais plutôt un message en rouge, pas d’inquiétude, le matériel n’est pas forcément défectueux !

En effet, plusieurs erreurs sont possibles :

Fonctionnement global

Partons du programme

Le contenu

Le programme est ce qui va définir chaque action que va exécuter la carte Arduino. Mais ce n’est pas tout ! Dans le programme il y a plusieurs zones, que nous verrons plus en détail tout au long de la lecture de ce cours, qui ont chacune un rôle particulier.

En conclusion, tout (vraiment tout !) ce que va faire la carte est inscrit dans le programme. Sans programme, la carte ne fait rien ! C’est grâce au programme que la carte Arduino va savoir qu’une LED est connectée sur sa broche 13 et ce qu’elle va devoir faire avec, allumer et éteindre la LED alternativement pour la faire clignoter.

L'envoi

Lorsque le programme est envoyé, le logiciel Arduino va alors vérifier si le programme ne contient pas d’erreur et ensuite le compiler (le traduire) pour l’envoyer dans la carte. En effet, le microcontrôleur de la carte n’est pas capable de « comprendre » le code que nous avons écrit. Il faut passer par l’étape de la compilation, qui est en quelque sorte une traduction de ce code vers le langage compris par le contrôleur :

Quelques notions de programmation

Les variables

Ce sont des informations auxquelles on donne un nom. Les variables peuvent être de différents types, et leur valeur peut être amenée à changer au cours du programme.

On déclare une variable de la manière suivante :

Ici, j’ai déclaré une variable de type int (integer, une valeur entière) que j’ai appelée « monNombreEntier », et à laquelle j’ai attribué la valeur 12.

Certaines variables ne sont pas amenées à être modifiées. On peut alors ajouter le mot clé « const », afin que le compilateur nous avertisse si l'on essaie de modifier la valeur (par inadvertance). On utilise souvent ce mot clé pour les variables contenant des numéros de broche.

Les noms des variables ne doivent pas contenir d’accent, d’espaces ni de caractères spéciaux sauf l’underscore « _ ».
Par convention, les noms de vos variables commenceront toujours par une minuscule.

Les commentaires

Il est utile de pouvoir ajouter des commentaires à notre programme. Ceux-ci n’auront aucune incidence sur son fonctionnement, mais amélioreront grandement sa lisibilité et sa maintenabilité.

Tout ce qui suit « // » sur une même ligne ne sera pas pris en compte par le programme. De même pour tout ce qui se trouve entre « /* » et « */ », y compris cette fois sur plusieurs lignes.

Les conditions

Dans un programme, on aura souvent besoin de gérer des conditions. Pour cela, on dispose de l’opérateur « if ». Il permet des conditions de type « Si (condition) alors (action) ». Il est aussi possible d’ajouter une action pour le cas inverse (sinon) à l’aide de l’opérateur « else ».
L’utilisation est la suivante :

Voici les principaux opérateurs de comparaison pour les conditions

Les boucles conditionnelles

Les boucles permettent la répétition d’une partie du programme. Il en existe plusieurs, mais nous nous concentrerons sur les deux principales.

La boucle « while »

Il s’agit de la boucle la plus simple. Elle s’exécute tant que la condition est vraie.

Dans cet exemple, la boucle tournera tant que la variable « température » n’atteindra pas la valeur de 20.

La boucle « for »

On l’utilise pour exécuter un nombre donné d’itérations (une itération = un passage dans la boucle).

Dans cet exemple, « i » est notre compteur d’itérations. On l’initialise à 0.
Ensuite, on indique notre condition : « i < nombreIterations » signifie que l’on continuera d’exécuter notre boucle tant que « i » sera inférieur à la variable « nombreIterations ». Et pour finir, « i++ » signifie qu’à la fin de chaque itération, « i » est incrémenté.

Les librairies

Les librairies (ou bibliothèques) sont un ensemble de programmes prenant en charge certaines opérations. Elles permettent une certaine abstraction, simplifiant alors l’écriture d’un programme.

L’utilisateur n’a donc pas à se préoccuper de ce qui est fait par la librairie, il n’a qu’à se servir des différentes fonctions fournies afin d’arriver au résultat voulu.

La gestion d’un écran LCD serait par exemple complexe à réaliser en partant de zéro, alors qu’une fois la bonne librairie installée, quelques lignes de code suffisent à afficher ce que l’on veut !

Les librairies se trouvent dans le dossier C:\Users\*utilisateur*\Documents\Arduino\libraries.

Afin d’installer une librairie, il suffit de copier son dossier à l'emplacement indiqué ci-dessus, ou même de l’installer directement à l’aide du gestionnaire de librairies inclus avec le logiciel Arduino si la librairie s’y trouve.

Il existe des bibliothèques prenant en charge tout un tas de choses, parfois matérielles (pour gérer un LCD par exemple), et parfois uniquement logicielles (pour simplifier la réalisation de calculs mathématiques complexes par exemple).

La communication série

Important : la liaison série utilise les broches 0 et 1 de l’Arduino. Si on souhaite utiliser la liaison, alors il faut veiller à ne rien connecter à ces broches.

La liaison série est utilisée pour communiquer entre l’Arduino et un ordinateur ou un autre périphérique. Afin de l’utiliser, il faut commencer par initialiser la liaison en spécifiant le baud rate (vitesse) voulu. La commande « Serial.begin(baudRate) » est alors utilisée (attention au « S » majuscule). Une vitesse de 115200 est une bonne valeur par défaut.

Nous pouvons ensuite envoyer des informations à l’aide de 2 commandes principales :

Afin de pouvoir récupérer ces données sur l’ordinateur, il nous faut utiliser un émulateur de terminal série. L’IDE Arduino en contient un que l‘on peut démarrer en cliquant sur l’icône en forme de loupe en haut à droite :

Il ne reste qu’à s’assurer que le baud rate correspond avec celui utilisé dans notre programme

Le logiciel Arduino met aussi à notre disposition un traceur série. Celui-ci permet la réalisation de graphiques de manière très simple. Il suffit d’envoyer des nombres depuis notre programme, et le traceur s’occupe du reste !

Un écran comme celui-ci avec le moniteur série

Devient cela avec le traceur série

Mise en pratique : la station météo

Le potentiomètre

Le potentiomètre est un composant analogique. Une fois correctement connecté à notre carte, nous pourrons mesurer l’angle de ce dernier.

Nous pouvons le relier sur n’importe quelle entrée analogique de l’Arduino (de A0 à A5).

Il faudra simplement veiller à indiquer la même valeur dans notre programme. Ici, on a choisi le port A0.

Voici notre premier programme :

                                
// On déclare une variable qui contient le numéro du port sur lequel est
// branché le potezntiomètre
const int brochePotentiometre = A0;

void setup() {
  // On initialise la liaison série à une vitesse de 115200
  Serial.begin(115200);
}

void loop() {
  // On récupère la valeur du capteur
  int valeurPotentiometre = analogRead(brochePotentiometre);
  
  //On envoie cette valeur sur la liaison série (vers le PC)
  Serial.println(valeurPotentiometre);

  // On fait une pause entre chaque mesure
  delay(50);
}

Après avoir téléversé ce programme, vous pouvez ouvrir le moniteur série et manipuler le potentiomètre afin de visualiser l’évolution de la valeur. Essayez ensuite d’ouvrir le traceur série pour voir ces changements sous la forme d’un graphique.

Le capteur de luminosité

Ce capteur nous renvoie une valeur analogique sous la forme d’une tension qui va augmenter en même temps que la luminosité.

En vous basant sur le programme précédent (potentiomètre), écrire un programme qui permet de visualiser les variations de luminosité. Vous utiliserez le port A1, et vous nomerez vos variables « portCapteurLuminosite » et « valeurCapteurLuminosite ».

Code de la correction :

Le capteur de qualité d’air

Ce capteur nous renvoie une valeur analogique sous la forme d’une tension qui va augmenter quand la qualité de l’air se dégrade. Ce capteur donne une indication sur la teneur en monoxyde de carbone et en Composés Organique Volatiles (COV).

En vous basant sur le programme précédent, écrire un programme qui permet de visualiser les variations de qualité de l’air. Vous utiliserez le port A2, et vous nomerez vos variables « portCapteurAir » et « valeurCapteurAir ».

Code de la correction :

Le capteur de rayonnement UV

Ce capteur nous renvoie une valeur analogique sous la forme d’une tension qui va augmenter en même temps que son exposition aux rayonnements ultraviolets (UV).

En vous basant sur le programme précédent, écrire un programme qui permet de visualiser les variations d’UV. Vous utiliserez le port A3, et vous nomerez vos variables « portCapteurUV » et « valeurCapteurUV ».

Code de la correction :

La sonde de température

Contrairement aux 3 précédents capteurs, celui-ci ne nous renvoie pas ses mesures sous forme d’une tension variable, il utilise à la place un protocole numérique bien précis. Il s’agit du protocole OneWire.

Mais pas d’inquiétude, il existe une librairie qui va gérer pour nous le protocole OneWire.

Nous allons aussi utiliser une seconde librairie conçue spécifiquement pour communiquer avec la sonde que nous utilisons (sonde Dallas)

Nous allons donc commencer par installer ces deux librairies à l’aide du gestionnaire de librairies :


Nous allons relier la sonde de température sur le port 2, marqué « D2 » sur le shield Grove. Remplacez les *** par les éléments appropriés et testez votre programme.

                                
// On inclut les librairies nécessaires
#include 
#include 

// On crée une instance OneWire sur le port 2 afin de communiquer avec le capteur
OneWire oneWire(***);

// On crée une instance de capteur de température en utilisant le oneWire créé précedemment
DallasTemperature sensors(&oneWire);


void setup(void)
{
  // On initialise la liaison série avec une vitesse de 115200
  Serial.begin(***);

  // On initialise le capteur de température
  sensors.begin();
}

void loop(void)
{ 
  // On effectue la mesure
  sensors.requestTemperatures(); // Send the command to get temperatures

  // On récupère la mesure du premier capteur, le seul dans notre cas.
  // On stocke cette mesure dans une variable de type "float", c'est une valeur décimale.
  float tempC = sensors.getTempCByIndex(0);

  // Si la valeur récupérée est valide, on l'affiche
  if(tempC != DEVICE_DISCONNECTED_C) 
  {
    Serial.print("Temperature : ");
    Serial.println(***);
  } 
  // Sinon, on indique qu'une erreur a eu lieu lors de la mesure
  else
  {
    Serial.println("Erreur lors de la mesure");
  }
}

Code de la correction :

Le baromètre

Ce capteur utilise ce qu’on appelle un bus I2C. Ce bus se trouve sur les ports A4 et A5 sur la carte Arduino UNO. Il faudra donc veiller à réserver ces ports à cette utilisation si vous voulez utiliser le bus.

Sur le shield Grove, on trouve des connecteurs pré câblés à ces ports, nommés « I2C ». C’est ici que nous relieront notre capteur. Tous les connecteurs « I2C » sont reliés ensemble.

Comme pour le capteur précédent, nous allons utiliser deux librairies pour faire fonctionner ce baromètre.

La première est la librairie « Wire », qui est préinstallée dans le logiciel Arduino, et qui est dédiée à la gestion du protocole I2C. La seconde nommée « Grove BMP280 » sera dédiée spécifiquement à la communication avec le capteur BMP280.

Installez la librairie « Grove BMP280 » et complétez le programme suivant. Les noms des variables à définir sont « temperature » et « pression »

                                
// On inclut les librairies
#include "Seeed_BMP280.h"
#include 

// On crée une instance du capteur
BMP280 bmp280;

void setup() {
    // On initialise la liaison série
    Serial.begin(***);

    // On tente d'initialiser le capteur
    // Si l'initialisation a échoué, on affiche un message d'erreur
    if (!bmp280.init())
    {
    Serial.println("Erreur de communication avec le capteur");
    }
}

void loop() {
    // On récupère les mesures
    float *** = bmp280.getTemperature();
    float *** = bmp280.getPressure();
    
    // On affiche les mesures
    Serial.print("Temperature : ");
    Serial.println(***);
    Serial.print("Pression : ");
    Serial.println(***);
    Serial.println();

    delay(100);
}

Code de déblocage du bilan :

La station

Réalisez le programme permettant de gérer tous les capteurs en même temps.

Code de déblocage pour une aide :

Code de déblocage de la correction :

Le shield carte SD

Attention : la carte SD (ou micro SD) doit avoir une capacité de 16Go maximum.

Installer la librairie nommée « SD ».

Branchez le potentiomètre an A0, recopiez et téléversez le programme ci-dessous, faites variez le potentiomètre et enfin regarder le fichier .csv créé avec Excel.

Demander le programme final

Code pour obtenir le programme final :

Idées

Ici vous trouverez quelques idées pour réaliser votre projet à partir de la station météo que l'on vient de construire. La liste n'est pas exhaustive, soyez créatif.

Projet 1

Mise en évidence du réchauffement climatique

Vous pouvez mesurer la température sur une longue période(1 mois) et regarder son évolution par rapport à il y a 10, 15 , 20 ans par exemple.

Pour cela il existe plusieurs sites "d'open data" où on peut trouvre les mesures réalisées à la station de Troyes/Barberey

Projet 2

Les plantes et les COV

Les plantes permettent-elles de purifier l'air ambiant?

Projet 3

Réchauffement climatique et pression

Avec le réchauffement climatique, la pression atmosphérique a-t-elle évoluée?

Projet 4

...

▲