Atelier Data-logger PIM

 

Atelier conçu par Jonathan Flye-Sainte-Marie, enseignant-chercheur à l’UBO (IUEM) avec la contribution de Maud Tournery, chargée d’enseignement fablab à IMT Atlantique licence CC-BY-SA

 

Introduction

 

L’objectif de cet atelier est de vous faire découvrir les bases de l’électronique numérique dans l’optique de fabriquer un petit prototype de data logger de température. Pour cela vous allez d’abord apprendre à programmer un micro-contrôleur, vous verrez ensuite les grands types de capteurs disponibles (capteurs analogiques et numériques) puis vous monterez et programmerez le fameux data-logger, qui permettra d’enregistrer la température (avec un pas de temps choisi) de façon autonome, les données horodatées seront enregistrées sur une carte SD. Inutile de vous dire que ce type d’outils est très utile en sciences de l’environnement.

Le cours est structuré en 6 chapitres, en fin de chapitre vous trouverez généralement des petits défis que vous pouvez réaliser si vous en avez pris de l’avance par rapport aux autres groupes.

Chapitre 1. Programmation de la carte

 

Étape 1 : Installer l’IDE Arduino

 

Le logiciel Arduino IDE (Intergrated Development Software) vous permettra de programmer et de communiquer avec la carte (ici la carte Firebeetle), c’est un peu le Rstudio pour les microcontrolleurs.

  1. Télécharger le logiciel Arduino IDE ici
  2. Suivez les instructions disponibles ici pour l’installer sur votre ordinateur.
  3. Une fois installé, vous pouvez lancez le logiciel

 

Étape 2 : Installer la bibliothèque pour la carte Firebeetle

 

L’IDE Arduino permet de programmer différents microcontrôleurs. Ici, nous allons utiliser une carte Firebeetle qui n’est pas une carte Arduino, elle est basée sur un microcontrôleur de type ESP32 (une “famille” de micro-controlleurs trés répendus, peu chers et puissants qui intègrent des fonctionalités WIFI et Bluetooth), il faut donc installer une librairie pour permettre à l’IDE Arduino de le programmer. Pour cela vous pouvez suivre le tuto suivant :

  1. Dans le menu File > Preferences
  2. En bas de la page, ajoutez :

https://dl.espressif.com/dl/package_esp32_index.json dans « Additionnal board manager URLs »

  1. Validez en cliquant sur OK
  2. Allez dans le menu Tools>Board>Boards manager et recherchez ESP32
  3. Installer la librarie “ESP32 by Espressif systems”

Étape 3 : Télécharger votre premier code

 

  1. Connectez le câble USB à votre ordinateur et à la carte.
  2. Vous devez maintenant indiquer à l’IDE Arduino que vous voulez programmer une carte Firebeetle, allez dans le menu Tools>Board>esp32 et sélectionnez la carte “FireBeetle-ESP32”.
  3. Sélectionnez le port de communication dans Outils>Port (cela doit ressemble à quelque chose comme “COM” suivi par un numéro sous Windows).

Bravo ! Votre carte est prête à être programmée.

 

Étape 4 : Écrivez votre premier code et téléchargez-le sur le tableau.

 

Dans le panneau principal du logiciel, vous pouvez éditer un programme.  Nous allons réaliser un programme très simple.

  1. Copiez le code suivant dans la fenêtre de l’éditeur.

 

void setup() {

Serial.begin(115200) ; // Ouvrir la communication série

}

void loop() {

Serial.println("Vive le PIM !") ; // imprime quelque chose sur le port série

delay(1000) ; // attendre 1000 ms

}

 

  1. Sauvegarder le code (ne pas mettre d’espace dans le nom du fichier)
  2. Vérifiez le code en cliquant sur cette icône :
  3. Si vous n’obtenez pas d’erreur, vous pouvez téléverser le code en cliquant sur cette icône : . Cette opération va en fait programmer votre microcontrôleur qui pourra exécuter le programme (même s’il n’est plus connecté avec votre ordinateur).
  4. Lors de ce téléversement du texte doit défiler dans la fenêtre a fond noir en bas (Output), tant qu’il n’y a pas de message d’erreur tout va bien !

 

Étape 5 : Voir le résultat

 

Si vous n’obtenez pas d’erreur, c’est parfait ! Mais maintenant vous voulez peut être voir le résultat de votre programme. Pour cela :

  1. Allez dans le menu Tools>Serial Monitor
  2. En cas d’erreur, vérifiez la configuration du port (testez un autre COMXX) et ouvrez à nouveau le moniteur série.
  3. Vous devriez voir « Vive le PIM ! » s’afficher toutes les secondes dans le moniteur série.

 

Bravo, vous êtes maintenant prêt pour la suite !

 

Chapitre 2. Premier pas en électronique numérique : faire clignoter une LED

 

Les microcontrôleurs permettent d’utiliser certains de leurs pins (broches) en tant que « sorties ». C’est-à-dire que de façon logicielle (en programmant le microcontrôleur), nous allons pouvons définir si le pin est dans un état :

  • « HIGH », ce qui signifie que le pin délivre une tension égale à la tension de fonctionnement du microcontrôleur: ici 3,3V.
  • « LOW », ce qui signifie que la tension sur le pin concerné est de 0V.

Cette fonctionnalité est une fonctionnalité de base d’un microcontrôleur, elle permet, de contrôler des composants connectés au pin en question. Par exemple, d’allumer ou d’éteindre une LED. Voyons comment nous pouvons réaliser cela. La première chose à faire est de jeter un œil au « pinout » du microcontrôleur, qui est la « carte » où l’on peut trouver toutes les fonctionnalités qui peuvent être associées à chacun des pin du micro-contrôleur, voici le « pinout » de la carte FireBeetle :

Toutes les pins indiqués par un « IO » sont censées avoir cette fonctionnalité, ce qui exclut les pins en rouge (alimentation) et ceux en noir (masse) ainsi que les pins NC (non connectés) et RST (réinitialisation).

Les pins marquées d’un D sont généralement dédiées à cette fonction. Mais certaines de ces broches ont aussi d’autres fonctionnalités (par exemple, D0 et D1 ont aussi les fonctionnalités TX et RX, qui est un protocole de communication que nous verrons plus tard). Un bon choix est donc IO25/D2 qui n’a pas d’autres fonctionnalités.

Maintenant que nous avons identifié le pin IO25, connectons-la à une LED. Nous devrons ajouter une résistance de 47 Ohm pour protéger la LED (histoire de ne pas la griller).

Il est maintenant temps de souder les connecteurs sur le Firebeetle.  Une fois que c’est fait, branchez la Firebeetle sur la plaque d’essai. Et câblez comme indiqué ci-dessus.

Attention à la polarité lors du montage de la LED ! La patte courte (-) de la LED du côté plat doit être connecté à la broche GND du microcontrôleur tandis que la patte longue (+) doit être connecté à la broche IO25 (Notez que vous pouvez utiliser votre LED verte au lieu d’une LED rouge).

Bravo, vous avez réalisé votre premier schéma électrique !

 

Maintenant, programmons le microcontrôleur :

  1. Ouvrir une nouvelle esquisse dans l’IDE Arduino
  2. Lisez le sketch (programme) vide, vous y trouverez deux déclarations vides :
    • setup : Le code contenu dans cette déclaration ne sera exécuté qu’une seule fois, lors de la mise sous tension ou de la réinitialisation du microcontrôleur. Le code dans le setup est donc utilisé pour les initialisation.
    • loop : L code contenu dans cette déclaration sera exécuté continuellement en boucle.
  3. Dans le setup, nous devons ajouter le code pour définir la broche comme « OUTPUT ».
  4. Dans la boucle, nous devrons ajouter un code qui :
    • mette l’IO25 dans l’état HIGH : cela alimentera la LED
    • attendre un certain temps (essayons 500ms)
    • puis mette l’IO25 dans l’état LOW : ceci éteindra la LED
    • attendre un certain temps (essayons 1000ms)

 

Le code suivant permet d’effectuer ces opérations :

/Définition

const int greenled = 25 ; // Définir le pin IO25 comme pin LED

// la fonction de configuration s'exécute une fois lorsque vous appuyez sur reset ou que vous mettez la carte sous tension

void setup() {

// Définir la broche pour le geenled en tant que sortie

pinMode(greenled, OUTPUT) ;

}

// la fonction en boucle s'exécute à l'infini

void loop() {

digitalWrite(greenled, HIGH) ; // allume la LED (HIGH est le niveau de tension)

delay(500) ; // attendre 500 millisecondes

digitalWrite(greenled, LOW) ; // éteint la LED en mettant la tension à un niveau BAS

delay(1000) ; // attendez une seconde

}

Maintenant, téléchargez le code (vous savez comment faire) et vérifiez que la led clignote.

Vous pouvez modifier les valeurs du délai pour changer la façon dont le voyant clignote.

 

Défis (à faire si vous avez le temps)

  • faire clignoter une 2ème LED, les 2 LEDs s’allumant en même temps et s’éteignant en même temps
  • décaler le clignotement des 2 LEDs : la LED A s’allume quand la B s’éteint et inversement
  • faire clignoter la LED A pendant que la LED B reste allumée.

 

Chapitre 3 : Capteurs analogiques basiques

 

Les microcontrôleurs permettent de communiquer avec différents types de capteurs ou d’en lire le signal. Nous entendons par capteur tout composant qui peut fournir des informations (électriques ou électroniques) sur son environnement. Nous pouvons classer les capteurs en deux grandes « familles » :

  • les capteurs analogiques : ils émettent un signal électrique (tension) qui dépend d’une variable de l’environnement
  • les capteurs numériques : plus complexes, ils communiquent numériquement (comme le Firebeetle communique à l’ordinateur) une valeur ou un ensemble de valeurs qui dépendent de variables de l’environnement.

Dans cet exercice, nous allons d’abord nous intéresser à un capteur analogique de des plus basique : un bouton poussoir, qui capte la présence ou l’absence de pression. Ce type de capteur est (généralement) normalement ouvert (OFF), mais qu’on le presse le contact se fait et il laisse passer le courant (ON).

 

Objectifs de l’exercice

 

Nous allons réaliser un circuit et programmer le Firebeetle permettant :

  • d’allumer la led lorsqu’un une pression est exercée sur le poussoir
  • éteindre la LED lorsque lorsque la pression est relâchée.

(Notez que ceci peut être fait sans micro-contrôleur, en utilisant simplement le poussoir pour contrôler la puissance de la LED, mais on est là pour jouer avec le Firebeetle !)

 

Étape 1 : contrôler l’alimentation de la LED à partir du Firebeetle

 

Nous l’avons déjà fait dans l’exercice précédent. Il suffit d’utiliser le même circuit. Rappelez que nous avons utilisé l’IO25 comme sortie pour alimenter la LED.

 

Étape 2 : circuit pour le bouton poussoir

 

  1. Tout d’abord, nous devons choisir un pin pour lire l’état du capteur. Comme le capteur est un capteur de type ON/OFF, le pin doit être capable de lire soit une valeur 0V (LOW) soit une valeur 3V3 (HIGH). N’importe quel pin IO peut faire cela (rappelez-vous que IO signifie Entrée/Sortie). Nous pouvons choisir IO26.

 

Nous allons maintenant connecter le bouton poussoir entre la broche 3V3 et IO26 comme dans l’image ci-dessous.

Étape 3 : Programme

 

Le programme que nous allons écrire doit :

  1. Placer le pin IO26 en mode INPUT : nous voulons lire l’état de cette broche : qui sera soit HIGH si la tension de la broche est de 3V3 (bouton poussoir pressé), soit LOW si la tension de la broche est de 0V (pas de pression sur le bouton poussoir).
  2. Inclure une boucle qui :
    1. Vérifier l’état de la broche IO26
    2. Allume la LED, en d’autres termes, fait passer l’état du pin IO25 en HIGH si le pin IO26 est en état HIGH.

Le programme devrait donc être :

/Définition

const int greenled = 25 ; // Définir la broche IO25 comme broche LED

const int reed = 26 ; // Définir la broche IO26 comme broche Reed

// la fonction de configuration s'exécute une fois lorsque vous appuyez sur reset ou que vous mettez la carte sous tension

void setup() {

// Définir la broche pour le geenled en tant que sortie

pinMode(greenled, OUTPUT) ;

// Définit la broche de l'anse comme entrée, PULLDOWN permet d'amener la broche à GND (0V).

pinMode(reed, INPUT_PULLDOWN) ;

}

// la fonction en boucle s'exécute à l'infini

void loop() {

if(digitalRead(reed)==HIGH){

digitalWrite(greenled, HIGH) ;

}

else{

digitalWrite(greenled, LOW) ;

}

}

 

Étape 4 : Téléverser le code et l’essayer

 

  1. Vous pouvez maintenant connecter la carte à votre ordinateur, sélectionner le bon port, débugger le code et le téléverser.
  2. Essayez de presser le bouton poussoir et voyez si le voyant s’allume.

 

Défis (à faire si vous avez le temps)

  • Afficher l’état du bouton poussoir dans le moniteur série.
  • Laisser la LED allumée par défaut, l’éteindre quand le bouton poussoir est au niveau HIGH.

 

Applications possible des ce type de capteurs 

Vous l’avez compris, les capteurs de type ON/OFF permettent de déterminer un état binaire, ils peuvent par exemple être appliqués pour :

  • déterminer si un bac (réservoir) est plein ou non avec un capteur équipée d’un flotteur
  • déterminer un état d’ouverture (porte, vanne)…

 

Chapitre 4 :  Capteurs analogiques typiques

 

Dans l’exercice précédent, nous avons vu comment traiter le signal d’un capteur de type ON/OFF qui nous permet de capter un signal binaire.  Nous allons maintenant nous intéresser à un capteur plus complexe : un capteur qui ne détermine pas uniquement un état binaire mais dont la tension de sortie varie  entre 0V et une tension maximale (ici 3V3) en fonction de la variable que l’on souhaite mesurer. Ce type de capteur est très courant (c’est probablement le type le plus rependu). Afin de lire un tel capteur à partir de notre microcontrôleur nous voulons maintenant non plus lire un état binaire (HIGH/LOW) mais lire une tension sur un des pins. La plupart des micro-contrôleurs sont capables de faire cela, mais implique l’utilisation de pins spécifiques du micro-contrôleur : les « pins analogiques ». Vous devez vérifier la carte de pinout pour choisir un pin qui dispose de cette fonctionnalité, elles sont généralement nommées A0, A1… Vous pouvez voir que les pins IO15, IO35, IO34, IO39, et IO 36 sont respectivement les pins A4, A3, A2, A1 et A0 ce qui signifie qu’elles sont tous des pins analogiques.

Comment fonctionnent ces broches analogiques ?

Si une tension est appliquée sur l’une de ces broches, le microcontrôleur est capable, grâce à l’un de ses composants appelé ADC (Analogic to Digital Converter), de comparer cette tension à une tension de référence, et il renverra une valeur proportionnelle au rapport entre les tensions. Il existe plusieurs résolutions de convertisseurs analogiques-numériques ; dans les microcontrôleurs courants, les ADC fonctionnent généralement sur 10 ou 12 bits. Cela peut paraître compliqué, mais pas de panique, ce qu’il faut retenir c’est que :

  • Un ADC 10bits : peut sortir des valeurs entre 0 et 1023 (2^10 – 1, car 0 est aussi une valeur).
  • Un ADC 12bits : peut sortir des valeurs entre 0 et 4095 (2^12 – 1, car 0 est aussi une valeur).

 

Par exemple, notre FireBeetle dispose d’ADC 12bits, et la tension de référence est de 3.3V. Supposons que nous appliquions une tension de 1,15V sur une broche analogique. L’ADC retournera une valeur égale à 1.15/3.3 = 0.35 fois la valeur maximale de l’ADC (4095), donc la valeur retournée par l’ADC sera 0.35 x 4095 = 1433.

 

Autre exemple, si nous appliquons une tension de 3V, alors l’ADC renverra (3/3.3)x4095 = 3723, si la tension est de 0.3V alors l’ADC renverra 372, etc…

 

On notera que :

– si la tension est de 0V, la valeur renvoyée par l’ADC sera 0

– si la tension est supérieure à 3,3V, la valeur sera 4095 (l’ADC n’est pas en mesure de renvoyer une valeur supérieure à 4095).

 

Notons également que :

Si la tension de référence est de 3,3 V et que nous travaillons avec un ADC à 12 bits, la résolution de la lecture sera de 3,3/4096=0,0008 V, ce qui donne 0,8 mV (ce qui est déjà une résolution très élevée).

 

Entraînons-nous !

 

Une façon de construire un capteur analogique simple est d’utiliser un potentiomètre, qui n’est rien de plus qu’une résistance variable, et qui ressemble à ceci :

 

Les potentiomètres sont largement utilisés en électronique, par exemple pour contrôler le volume d’une radio. Le schéma ci-dessus illustre son fonctionnement. Lorsque l’on tourne l’axe, le curseur se déplace le long de l’élément résistif et la résistance entre B (point central) et C et entre B et A varie (notez que la résistance entre A et C ne dépend pas de la position de l’axe).

 

Supposons maintenant que le potentiomètre soit monté selon le schéma suivant :

 

Il agira comme un diviseur de tension (voir ce lien pour des explications). Ainsi si B est très proche de A, la tension entre B et GND sera proche de 3V3, et si B est proche de C, la tension entre B et GND sera proche de 0V, en position intermédiaire la tension entre B et GND dépendra de la position de B entre A et C. Ainsi la lecture de la tension entre B et GND renseigne sur la position de l’axe. Nous avons ici un capteur de position analogique, c’est une utilisation possible des potentiomètres (capteur d’angle de barre sur les pilote automatiques, capteur d’ouverture d’un robinet…).

 

Objectifs de l’exercice

L’objectif de cet exercice est d’utiliser le potentiomètre comme capteur analogique et de dessiner un graphique qui trace une valeur en fonction de la position de l’axe du potentiomètre.

 

Etape 1 : Le montage électronique

 

sur le Firebeetle nous utiliserons le pin IO34 comme pin analogique du microcontrôleur. Connectez le point central du potentiomètre (B, fil jaune) à IO34, une extrémité à 3V3 (fil rouge) et l’autre au GND (fil noir). 

remarque : le potentiomètre utilisé a une connectique un peu spécifique, appelée Grove. Il suffit d’utiliser des fils électriques mâle/mâle entre le connecteur et l’esp32.

 

Etape 2 : Le code

 

Maintenant que la connexion est faite, nous allons programmer le Firebeetle, le programme devra avoir les caractéristiques suivantes:

  1. Lecture du pin analogique
  2. Envoyer la valeur à l’ordinateur (nous avons fait quelque chose de similaire lors du premier chapitre)

 

void setup() {

Serial.begin(115200) ; // Ouverture de la communication série

pinMode(34, INPUT) ;

}

void loop() {

int val = analogRead(34) ; // Lecture de la valeur du pot

Serial.println(val) ; // Envoi de la valeur sur le port série

delay(250) ; // attendre 500 ms

}

Etape 3 : Visualisation du résultat

 

Dans l’IDE Arduino, allez dans Tools>Serial Monitor, tournez l’axe du potentiomètre et vous devriez voir la valeur changer. Vérifiez le port si nécessaire.

Allez maintenant dans Tools>Serial plotter, une courbe dessinant les valeurs données par le Firebeetle sera dessinée, vous pouvez maintenant tourner l’axe du pot et voir graphiquement le résultat.

Défis (à faire si vous avez le temps)

 

  • Allumer la LED dès qu’on mesure une tension ≥ 1,5 V sur la broche B du potentiomètre

 

Conclusions

Au cours de cet exercice, vous avez compris et mis en œuvre les bases des capteurs analogiques. Mais vous avez aussi réalisé un capteur numérique : le potentiomètre + les microcontrôleurs constituent un système qui permet de renvoyer numériquement une valeur qui dépend d’une variable de l’environnement (ici la position de l’axe). Cette valeur peut être affichée et tracée sur un ordinateur. Bravo ! Gardez à l’esprit qu’un capteur numérique fonctionne de cette manière, il s’agit généralement d’un composant comprenant un capteur analogique + un (petit) microcontrôleur. Le prochain exercice portera sur les capteurs numériques.

 

Chapitre 5 : Capteurs numériques

 

Comme nous l’avons vu dans l’exercice précédent, un capteur numérique est un capteur qui permet de transférer numériquement des informations sur l’environnement à un autre composant / microcontrôleur / ordinateur. De tels capteurs (ou composants) sont très couramment utilisés.

 

Protocoles de communication numérique communs :

Trois principaux protocoles de communication sont couramment utilisés : UART, I2C et SPI. L’idée ici n’est pas d’entrer dans le détails de ces chacun de ces protocoles, mais il est utile de les connaître un minimum pour pouvoir les utiliser.

 

Le protocole UART

https://fr.wikipedia.org/wiki/UART

Il s’agit d’un protocole de communication assez ancien. Bien qu’encore très utilisé il présente certaines limites qu’il convient de conaître. Vous avez déjà manipulé ce protocole car c’est celui-ci qui est utilisé par notre microcontrôleur communiquer avec l’ordinateur : c’est ce protocole qui se cache sous la commande Serial.print() que nous avons déjà utilisée (techniquement il est virtualisée via l’USB pour communiquer avec le PC).

 

Ce protocole nécessite, a minima, trois câbles : GND, TX (transmission), RX (réception). Supposons deux objets (ITEM1, un FireBeetle par exemple ; ITEM2, un GPS par exemple) utilisent ce protocole pour communiquer, ils seront câblés selon le schéma suivant :

 

Notez que les lignes TX (bouche) et RX (oreille) doivent être croisées : l’ITEM1 parlera à travers son TX et l’ITEM2 écoutera à travers son RX et inversement. Vous comprenez maintenant que le fait de câbler les TX des deux objets ensemble et les RX ensemble ne fonctionnera pas (la bouche de l’ITEM1 parlera à la bouche de l’ITEM 2, et l’oreille de l’ITEM1 sera en face de l’oreille de l’ITEM2, pas facile de communiquer de cette façon là!). Il s’agit d’une erreur très courante !

 

La vitesse de communication de ce protocole (débit en bauds) doit être configurée, rappelez-vous que nous avons utilisé la commande : Serial.begin(115200) ; ce qui signifie que nous démarrons une communication série (UART) avec un débit en bauds de 115200 (bits/s). Les baudrates couramment utilisés sont 4800, 9600 et 115200bits/s .

 

Une limitation importante de ce protocole est que sur une ligne de communication, seuls deux éléments peuvent communiquer ensemble. Si vous voulez que l’élément 1 (c’est-à-dire le firebeetle) communique avec un troisième élément, vous aurez besoin d’une autre paire de fils TX et RX.

 

En océanographie, un grand nombre d’instruments utilisent un tel protocole, par exemple les GPS : la plupart des GPS utilisent le protocole UART. Un certain nombre de capteurs océanographiques (les fluorimètres par exemple) utilisent le protocole RS232, qui est identique à l’UART mais dont la tension est typiquement comprise entre -12V et 12V alors que les micro-contrôleurs UART utilisent des tensions comprises entre 0V et 3V3 ou 5V. Les capteurs RS232 peuvent facilement être interfacés avec un micro-contrôleur en utilisant un composant spécifique (max232 ou équivalent).

 

Le protocole I2C

Il s’agit d’un protocole plus récent qui est désormais très couramment utilisé pour interfacer un microcontrôleur avec d’autres composants, généralement des capteurs. Dans ce protocole, un « maître » échange des informations avec un ou plusieurs « esclaves ». La communication se fait toujours à l’initiative du maître. Une caractéristique très intéressante de ce protocole est que plusieurs composants peuvent communiquer sur une seule ligne (bus). Cela est rendu possible par le fait que le maître contrôle la communication des autres composants. Pour ce faire, chaque composant possède une adresse spécifique (qui doit être configurée dans le code). Nous n’entrerons pas dans les détails du fonctionnement de ce protocole. Le protocole I2C est typiquement câblé de la façon suivante :

Il a besoin de deux fils SDA (Serial Data line) et SCL (Serial Clock line) en plus du GND. Mais notez que plusieurs capteurs sont connectés à la même ligne. Notez également que les deux lignes doivent être connectées à Vdd (le 5V ou 3.3V du micro-contrôleur) par l’intermédiaire de résistances dite de pull-up. Si vous ne les connectez pas, la communication ne fonctionnera pas. Les résistances pull-up sont généralement de 1KOhm (marron, noir, rouge).

Pour en savoir plus sur le protocole I2C, consultez le site : https://fr.wikipedia.org/wiki/I2C

 

Le protocole SPI

Le protocole SPI fonctionne de la même manière que le protocole I2C, c’est-à-dire que plusieurs périphériques (capteurs, mémoires) peuvent communiquer avec un maître (c’est-à-dire un micro-contrôleur) sur un seul bus. Le câblage est un peu plus complexe, il nécessite 3 câbles (un de plus pour chaque périphérique) :

Vous pouvez en savoir plus sur ce protocole à l’adresse suivante : https://fr.wikipedia.org/wiki/Serial_Peripheral_Interface

Ce protocole est moins courant pour la communication avec les capteurs que le protocole I2C, mais c‘est le protocole de communication typique qui utilise les cartes SD.

 

Autres protocoles

Il existe d’autre protocoles de communication qui sont moins couramment utilisés mais que vous pourrez être amenés à uiliser, un exemple est le protocole OneWire, qui est un protocole qui comme son nom l’indique n’a besoin que d’un cable (en plus du GND) et sur lequel on peut mettre plusieurs capteurs

 

En pratique, comment utiliser ces capteurs avec un micro-contrôleur ?

 

La première chose à faire est de câbler correctement le capteur à votre micro-contrôleur. Pour cela, vous devez consulter le pinout de votre micro-contrôleur : vous connaissez déjà celui du Firebeetle :

  • Ports UART : les broches IO0 et IO1 sont respectivement désignées par TXD et RXD. Il s’agit des broches série matérielles (UART) de la carte. Cela peut être un problème car il n’y a qu’un seul port et on a généralement besoin d’un port par capteur qui utilise ce protocole. En fait, presque toutes les broches numériques (désignées par D dans la carte de brochage) peuvent être utilisées comme port UART en utilisant la librairie « softwareserial ».
  • Ports I2C : Les pins IO21 et IO22 sont les pins SDA et SCL respectivement, vous devez les relier par des résistances de pullups (environ 1Kohm) au 3V3 du micro-contrôleur.
  • Ports SPI : Les pins IO18, IO19 et IO23 sont respectivement les pins SCK (ou SCLK), MISO et MOSI. En outre, toute autre broche numérique doit être utilisée comme « chipselect » (communément SS ou CS).

 

Vous devez ensuite programmer votre microcontrôleur pour qu’il communique avec les capteurs. Si vous avez jeté un coup d’œil aux pages du wiki, vous pensez probablement que vous en êtes incapables car c’est trop complexe ! N’ayez pas peur, Arduino et autres microcontrôleurs consorts sont spécialement conçus pour ce type d’application et ils disposent de moyens simples pour programmer les communications avec les capteurs.

 

La communication par UART est native dans Arduino et co, elle se fait en utilisant les commandes de la « famille » Serial.blabla(blabla) ; vous avez déjà utilisé ce protocole de communication pour communiquer avec l’ordinateur !

 

La communication par I2C utilise la bibliothèque « Wire », de plus la plupart des capteurs ont aussi une bibliothèque spécifique avec des commandes simples pour communiquer avec les capteurs. C’est le cas de celui que nous utiliserons dans le prochain exercice.

 

La communication avec le SPI utilise la bibliothèque SPI, et la communication avec la carte SD (utile pour un datalogger) se fait par l’intermédiaire d’une bibliothèque nommée « SD ».

Conclusions

Ce chapitre était très théorique, mais il vous a permis de découvrir les différents protocoles de communication avec des capteurs (ou autre composants) numériques. A première vue cela peut paraître complexe, mais vous avez pu constater que :

– le pinout de la carte permet de déterminer comment connecter ses capteurs

– qu’il existe des librairies qui permettent de qui permettent d’exploiter ces protocoles de façon simple

 

Dans le chapitre suivant nous vous proposons de mettre en pratique ces protocoles en construisant un petit data-logger de température.

 

Chapitre 6 : fabrication d’un data-logger de température

 

Objectifs

 

Fabriquer un système autonome capable de :

  • Lire la température
  • Lire une horloge
  • Enregistrer les données sur une carte SD

Vous vous doutez bien, qu’en océanographie, comme dans le recherche en général la capacité à enregistrer de façon autonome des mesures environnementales a de très nombreuses applications.

 

Etape 1 : Lecture du capteur de température

 

Nous allons travailler avec capteur numérique de température très courant, le 18B20, qui communique avec le protocole OneWire (évoqué rapidement dans le chapitre précédent). Lorsque l’on découvre un nouveau composant, il est toujours utilse d’aller consulter sa feuille technique (« datasheet »), on y trouve pas mal d’information très utiles concernant les spécification techniques du capteur :

Caractéristiques Valeur
Tension d’alimentation 3V à 5,5V
Gamme de température -55ºC à 125ºC
Erreur (-10ºC a 85ºC) ±0,5ºC
Erreur (-55ºC a 125ºC) ±2ºC
Résolution programmable 9-bit, 10-bit, 11-bit o 12-bit (default)

On y trouve également la configuration des connections :

Fonction des “pins” :

  • VDD: positif de l’alimentation.
  • GND: Négatif de l’alimentaion.
  • DQ (data) : pin permettant le communication grâce au protocole 1-Wire. (ce protocole permet de connecter plusieurs capteurs sur le même ligne).

 

 Le câblage à réaliser est le suivant (le composant noir correspond à la sonde de température)

 

 

Pin capteur Pin ESP32
GND GND
VCC /Vpp 3V3
DQ/data IO2 / D9

 

Il ne faut pas oublier d’ajouter d’ajouter une résistance de pullup de 4,7K entre data et  VCC.

 

Installer les librairies

Dans l’IDE Arduino : Tools> Manage librairies

  • OneWire.h
  • DallasTemperature.h

 

 

Programmation

 

  • Charger le programme 3_temp_sensor.ino (disponible sur Notion)
  • Le téléverser sur le firebeetle
  • Vérifier les sorties sur le port série

 

Défi (a faire si vous en avez le temps)

Allumer une LED lorsque la température dépasse 20°C (si vous allumiez un groupe froid votre montage se comporterai comme un thermostat)

 

Etape 2 : Lire l’horloge

 

Pour cela nous allons utiliser un petit module RTC (Real Time Clock) qui communique avec le protocole I2C (très courant!). Il existe de nombreux modules RTC, celui que nous allons utiliser est basé sur le chip DS3231. Il présente :

  • un faible dérive
  • un slot pour une pile (pour qu’il ne perde pas l’heure lorsque la carte n’est pas alimentée
  • une librairie qui permet de communiquer facilement

 

Le câblage à réaliser est le suivant

 

Attention il existe plusieurs modules différents dont les pinout peuvent changer, il faut donc se référer au tableau ci-dessous :

 

Pin RTC Pin ESP32
GND GND
VCC /Vin 3V3
SCL SCL/IO22
SDA SDA/IO21
Librairies
  • DS3231.h
  • Wire.h

 

Test et réglage de l’horloge
  • Charger le programme Test_and_Def_heure.ino (disponible sur Notion)
  • Modifier les valeurs dans le code pour le ajuster à dans 1 minute
  • Programmer le Firebeetle
  • Vérifier le bon réglage de l’heure

 

Agrégation de la température et de l’heure
  • Charger le programme 4_temp_RTC.ino
  • Programmer le firebeetle
  • Vérifier les sorties sur le port série

 

Etape 3 : Sauvegarder les données sur une carte SD

 

Nous allons maintenant ajouter une carte microSD et son support (slot) pour y enregister les données. Pour cela nous allons utiliser une module très courant (il en existe de nombreux), qui communique avec le protocole SPI (que nous avons vu dans le chapitre précédent) qui est le standard pour la manipulation de cartes SD.

 

Le montage à réaliser est le suivant

 

 

Il existe de nombreux modules différents, et le pinout est susceptible de varier d’un modèle a un autre. Il faudra donc adapter le câblage en fonction du module et se référer au tableau suivant :

 

Pin MicroSD Pin ESP32
GND GND
VCC /Vin 3V3
DO/MISO IO19/MISO
DI/MOSI IO23/MOSI
SCK/CLK IO18/SCK
CS IO5/D8
Librairie nécessaires 
  • SD.h
  • FS.h
  • SPI.h
Préparer la carte microSD
  • Vérifier le que la carte est bien formatée en FAT32
  • On évitera les cartes de trop forte capacité (SDXC)
  • On efface tous les fichiers de la carte

 

Programmation de la carte SD
  • Charger le programme 5_Temp_RTC_log.ino
  • Programmer le firebeetle
  • Vérifier les sorties sur le port série
  • Arrêter le module et vérifier que des données ont bien été enregistrées dans la carte SD, dans un fichier nommé « data.txt”
Bravo ! Vous venez de réaliser un dataloger auquel il ne suffit qu’une batterie (et un boîtier) pour être autonome !