Semaine 4 : Capteurs analogiques

Corrigé du TP Feu Tricolore+Feu piéton

Voici la correction du TP de la semaine dernière qui reprend des éléments du TP  1 : Feu tricolore ainsi que des éléments du cours 2 sur les capteurs numériques.

Nous profitons de cette page pour remercier les personnes qui nous ont alerté que l’intitulé de ce TP laissait planer quelques doutes. Merci beaucoup !

Pour les prochains travaux pratiques et exercices où les consignes vous semblent floues, n’hésitez pas à appliquer les conseils suivants :

1. Avertir la communauté et l’équipe pédagogique  sur le forum dans le fil de discussion dédié.
2. Prenez toujours les hypothèses qui vous arrangent.
3. Seules les notions abordées dans le cours et les annexes sont nécessaires pour mener à bien les TPs.
4. Il n’y a pas une mais plusieurs solutions à chaque problème. La meilleure est celle que vous comprenez !

Code

Voici une des solutions possibles pour répondre au problème dans l’état actuel de nos connaissances.

Sachez cependant que ce code n’est pas parfait car l’appui sur le bouton n’est détecté que si l’on appuie pendant tout le feu vert voiture. Dans quelques semaines, nous verrons comment être plus réactif.

/* 
  Feu tricolore + Feu Piétons
 
 TP de la semaine 3 du MOOC "La Fabrication Numérique" 
 
 Le montage :
 * Une LED rouge sur la broche 12 en série avec une résistance de 220Ω
 * Une LED orange sur la broche 11 en série avec une résistance de 220Ω
 * Une LED verte sur la broche 10 en série avec une résistance de 220Ω
 
 * Une LED rouge sur la broche 9 en série avec une résistance de 220Ω
 * Une LED verte sur la broche 8 en série avec une résistance de 220Ω
 
 * Bouton poussoir branché sur la broche 2 depuis +5V
 * Une résistance de 1KΩ branché sur la broche 2 depuis GND
 
 créé le 9 Avril 2014
 par Baptiste Gaultier
 avec les conseils de fb251
 
 Ce code est en CC0 1.0 Universal
 
 https://www.france-universite-numerique-mooc.fr/courses/MinesTelecom/04002/Trimestre_1_2014/about
 */

// Initialisation des constantes pour les LED
const int rouge = 12;
const int orange = 11;
const int verte = 10;

const int rougePieton = 9;
const int vertePieton = 8;


// Numéro de la broche à laquelle est connecté le bouton poussoir
const int bouton = 2;

// Déclaration des variables :
int etatBouton = 0;


// le code dans cette fonction est exécuté une fois au début
void setup() {
  // indique que les broches des LED
  // sont des sorties :
  pinMode(rouge, OUTPUT);
  pinMode(orange, OUTPUT);
  pinMode(verte, OUTPUT);
  
  pinMode(rougePieton, OUTPUT);
  pinMode(vertePieton, OUTPUT);
  
  // indique que la broche bouton est une entrée :
  pinMode(bouton, INPUT);
}

// le code dans cette fonction est exécuté en boucle
void loop() {
  // Dans le fonctionnement normal, le feu piéton est toujours rouge
  digitalWrite(rougePieton, HIGH);
  
  // Fonctionnement normal du feu voiture  
  digitalWrite(verte, HIGH);
  delay(3000);
  digitalWrite(verte, LOW);  
  
  // lit l'état du bouton et stocke le résultat
  // dans etatBouton :
  etatBouton = digitalRead(bouton);

  // Si etatBouton est égal à HIGH
  // c'est que le bouton est appuyé
  if (etatBouton == HIGH) {
    digitalWrite(orange, HIGH);
    delay(1000);
    digitalWrite(orange, LOW);
  
    digitalWrite(rouge, HIGH);
    
    // Le feu piéton passe au vert pendant 5s
    digitalWrite(rougePieton, LOW);
    digitalWrite(vertePieton, HIGH);
    
    delay(5000);
    
    // On remet le feu piéton au vert
    digitalWrite(rougePieton, HIGH);
    digitalWrite(vertePieton, LOW);
    
    // Puis on remet le feu au rouge
    digitalWrite(rouge, LOW);
  }
  else {
    // Fonctionnement normal du feu voiture
    digitalWrite(orange, HIGH);
    delay(1000);
    digitalWrite(orange, LOW);
  
    digitalWrite(rouge, HIGH);
    delay(3000);
    digitalWrite(rouge, LOW);
  }
}

Vous pouvez également télécharger le programme (appelé également croquis dans le logiciel Arduino) en cliquant ici et en l’ouvrant avec le simulateur ou le logiciel Arduino.

Montage électronique

Pour réaliser ce montage, vous avez besoin de :

• Un Arduino
• Une platine de prototypage
• Un câble USB
• Cinq résitances de 220Ω
• Une résistance de 10kΩ
• Des fils de prototypage
• Deux LED verte
• Une LED orange
• Deux LED rouge
• Un bouton poussoir
• Du temps

Notre correction s’arrête là. Pour des éclaircissements, nous vous invitons à poser vos questions sur le forum et à reparcourir le cours.

On vous laisse avec un montage réalisé par un des membres, ProPhil, qui nous a épaté avec cette photo :

Schéma électronique

Comme on nous l’a demandé sur le forum, voici le schéma électronique créé avec Fritzing :

Vous pouvez télécharger le transcript de la vidéo ici.

analogInOutSerial

Merci d’avoir regardé cette vidéo ! Voici quelques éléments pour mieux la comprendre :

Montage

Schéma

Pour le réaliser, vous aurez besoin de :

• Un Arduino
• Un câble USB
• Deux résitances de 1kΩ
• Des fils de prototypage
• Une platine de prototypage
• Une photorésistance
• Une LED de votre couleur préférée

Code

Cette suite d’instructions va allumer une LED branchée sur la broche 9. L’intensité lumineuse de la LED sera proportionnelle à la luminosité captée par la photorésistance branchée sur la broche A0 (notez bien le A0, le A qui précède le 0 signifie que c’est une entrée Analogique).

Lorsque vous utilisez le logiciel Arduino, le code peut être trouvé en cliquant sur Fichier→Exemples→03.Analog→AnalogInOutSerial.

/*
  Entrée et sortie analogiques + communications série
 
 Ce programme va allumer une LED branchée sur la broche 9.
 L'intensité lumineuse de la LED sera proportionnelle à la luminosité
 captée par la photorésistance branchée sur la broche A0.
 
 */

// Initialisation des constantes :
// Numéro de la broche à laquelle est connecté la photorésistance
const int analogInPin = A0;
// Numéro de la broche à laquelle est connectée la LED
const int analogOutPin = 9;

// Valeur lue sur la photorésistance
int sensorValue = 0;
// Valeur envoyée à la LED
int outputValue = 0;

void setup() {
  // Initialise la communication avec l'ordinateur
  Serial.begin(9600);
  
  // Indique que la broche analogOutPin est une sortie :
  pinMode(analogOutPin, OUTPUT);      
  // Indique que la broche analogInPin est une entrée :
  pinMode(analogInPin, INPUT);     
}

void loop() {
  // lit la valeur de la photorésistance et
  // stocke le résultat dans sensorValue :
  sensorValue = analogRead(analogInPin);            
  // change sensorValue vers une intervalle de 0 à 255
  // et stocke le résultat dans outputValue :
  outputValue = map(sensorValue, 0, 1023, 0, 255);  
  // envoie de cette nouvelle valeur sur la LED
  analogWrite(analogOutPin, outputValue);           

  // envoie tout ça vers l'ordinateur
  Serial.print("sensor = " );                       
  Serial.print(sensorValue);      
  Serial.print("\t output = ");      
  Serial.println(outputValue);
}

Remarques :

• Copiez-collez ce code dans le simulateur pour ne pas avoir à tout retaper. Saviez vous que vous pouvez accéder à la documentation d’une fonction en cliquant avec le bouton droit sur celle-ci puis en cliquant sur Trouvez dans la référence.
• Aussi, il faut bien attendre la fin du téléversement avant d’ouvrir le moniteur série dont on parle en dessous.

Instructions

Comme les semaines passées, voici une description des nouvelles fonctions utilisées (n’hésitez pas à cliquer sur les liens ci-dessous afin d’arriver sur la référence Arduino).

Les nouvelles instructions :

• analogRead() permet de lire l’état d’une broche analogique et de renvoyer une valeur numérique proportionnelle à la tension reçue. La carte Arduino comporte 6 voies, A0 à A5, connectées à un convertisseur analogique-numérique 10 bits. Cela signifie qu’il est possible de transformer la tension d’entrée entre 0 et 5V en une valeur numérique entière comprise entre 0 et 1023.

analogRead(analogInPin);

La valeur de retour de analogRead() peut être stockée dans une variable entière (c’est pour cela que nous devons déclarer une variable de type int pour stocker le résultat) :

sensorValue = analogRead(analogInPin);

• Serial est une librairie (un ensemble de fonctions) utilisée pour les communications par le port série entre la carte Arduino et un ordinateur ou d’autres composants. Ce port série permet l’envoie et la réception de suites de caractères sur les broches 0 (RX) et 1 (TX) avec l’ordinateur via le port USB. C’est pourquoi, si vous utilisez cette fonctionnalité, vous ne pouvez utiliser les broches 0 et 1 en tant qu’entrées ou sorties numériques. Si vous souhaitez visualiser le texte envoyé depuis l’Arduino vers votre ordinateur, vous pouvez utiliser le terminal série intégré à l’environnement Arduino. Il suffit pour cela de cliquer sur le bouton du moniteur série dans la barre d’outils (Rappel : il faut bien attendre la fin du téléversement avant d’ouvrir le moniteur série) :

• Dans la fenêtre qui s’ouvre, vérifier bien que vous êtes au même débit de communication que celui utilisé dans l’appel de la fonction Serial.begin. Par défaut le débit est de 9600 :

Les fonctions de la librairie Serial sont :

• Serial.begin permet d’initialiser la communication entre Arduino et votre ordinateur. Cette fonction doit être placée dans le bloc setup, elle doit être suivi d’un seul paramètre qui correpond au débit de communication en nombre de caractères échangés par seconde (l’unité est le baud) pour la communication série. De manière classique, nous choisirons de communiquer à 9600 bauds. Pour en savoir plus sur l’utilisation du port série et des débits possibles, cliquez ici.  Sans le Serial.begin dans le bloc setup, on ne peut utiliser les autres fonctions Serial.print et Serial.println.

Serial.begin(9600);

• Serial.print Cette fonction permet d’envoyer sur le port série une suite de caractères indiqué en paramètre. De la même façon,  Serial.println envoie une suite de caractères suivi d’un retour à la ligne :

Serial.print("Texte envoye vers l'ordinateur"); // sans retour à la ligne
Serial.println("Texte avec retour a la ligne"); // avec retour à la ligne

• Serial.print nous sera particulièrement utile pour une tâche que vous avez déjà faite sans vous en rendre compte : le débogage. Il n’est pas rare que vous téléversiez votre code sur Arduino sans problème, mais une fois sur Arduino le comportement de votre programme mais pas celui attendu. Des petites erreurs viendront souvent se glisser dans vos programmes car nous ne sommes malheureusement pas parfait et qu’un oubli est vite arrivé. Grâce à Serial, il nous sera possible d’indiquer quand nous allumons une LED ou lorsque nous faisons un test… Il nous sera ainsi possible de suivre le déroulement de notre programme ! Mais ce n’est pas tout, Serial.print et Serial.println peuvent également afficher la valeur de variables si nous indiquons un nom de variable en paramètre :

Serial.print("sensor = " );                       
Serial.print(sensorValue);

• map() permet de faire passer une valeur située dans une intervalle vers un autre.  Les paramètres de ces fonctions sont les suivants :
  -   variable qui se trouve dans l’intervalle initiale
  -   début de l’intervalle initiale
  -   fin de l'intervalle initiale
  -   début de l’intervalle visée
  

Grâce à cette fonction, nous allons donc nous retrouver avec une valeur proportion

map(sensorValue, 0, 1023, 0, 255); // sensorValue passe de l'intervalle 0→1023 vers 0→255

• analogWrite() va être utilisé dans ce programme pour moduler l’intensité lumineuse d’une LED branché sur la broche spécifiée avec le premier paramètre. Dans les semaines passées, nos LED étaient allumées ou éteintes. L’intérêt de analogWrite avec est de pouvoir régler l’intensité lumineuse en spécifiant un nombre (compris entre 0 et 255) dans le second paramètre de la fonction :

analogWrite(11, 0);  // éteint complètement la LED branché sur la broche 11
analogWrite(11, 90); // allume un tout petit peu la LED branché sur la broche 11
analogWrite(11, 255);// allume complètement la LED branché sur la broche 11

Simulateur

Pur ceux qui souhaiteraient utiliser le simulateur, la photorésistance est disponible en cliquant sur Add component puis sur LDR. Cependant, l’interaction avec la photorésistance est limité et se limite à cliquer dessus pour changer la valeur de sa résistance. Nous vous conseillons de le remplacer par un potentiomètre comme ci-dessous :

Références

• Référence standard du langage Arduino par Xavier Hinault
• Chapitre dédié aux capteurs du manuel Arduino de chez FlossManuals
• Compléments sur les capteurssur le wiki des petits débrouillards

Les références sont là pour vous aider et aller plus loin dans la compréhension des notions abordées dans ce cours donc on n’hésite pas à les consulter

Licence

Nous profitons de cette section pour remercier Xavier Hinault qui met à disposition sur son site www.mon-club-elec.fr une documentation détaillée et libre sur lequel s’appuie ce texte.

Composants passifs

Dans les semaines passées, nous avons pas mal discuté des résistances, composant incontournable dans les montages électroniques. Voici d’autres composants dits "passifs" que nous avons souvent besoin d’utiliser…

Les Diodes

"Ahhhhh…" j’entends déjà les puristes – "une diode est un semi-conducteur, pas un composant passif…" Eh oui, mais je vais traiter le sujet ici et maintenant car nous l’avons déjà vue plusieurs fois dans nos précédents montages.

La diode est le premier vrai composant électronique qui a été inventé.  Au début c’était en forme d’énorme tube électronique qui chauffait un max !  Maintenant elle existe sous plusieurs formes :

Leur fonction de base est toute simple : laisser passer le courant dans un seul sens. On peut penser à un tuyau d’eau : une diode est comme un clapet anti-retour. Voici le symbole électronique :

La forme de flèche n’est pas un hasard, le sens de la flèche indique le sens de circulation du courant électrique. En utilisation "normale", la diode laisse passer le courant quand l’anode est plus positive que la cathode. La cathode est identifiée sur une diode par une bande colorée (voir les photos).

Une forme spéciale de la diode est la diode électroluminescente, ou DEL. Son symbole : 

Les deux petites flèches indiquent que cette diode émet de la lumière… Rappelons notre montage de la semaine passée :

On voit bien que l’anode est au positif, et la cathode au négatif. (je sais – ce n’est pas la bonne valeur de résistance avec une alimentation de 3v…).

Si on inverse la LED, elle ne s’allume plus et le courant ne passe plus.

Références

• La page Wiki sur comment brancher une LED

Merci à Glenn Smith pour ce cours !

TP à faire pour la semaine 5

Cette semaine, nous allons tenter de réaliser un Thérémine lumineux qui est un bon exemple pour aborder les entrées analogiques.

Ce montage va être l’occasion d’approfondir les fonctions map et analogRead mais également de découvrir une nouvelle fonction liée à l’utilisation d’un buzzer piézo-électrique, un composant qui peut produire du son. Le buzzer piézo-électrique transforme l’impulsion électrique envoyée par une broche en une onde sonore de fréquence identique et audible.

L’exercice consiste à modifier l’exemple AnalogInOutSerial vu cette semaine et l’adapter pour que la luminosité mesurée par la photorésistance soit proportionnelle à la fréquence jouée un buzzer branché sur la broche 8 : plus la luminosité reçue par la photorésistance est importante, plus la fréquence jouée par le buzzer sera élevée (et inversement, si on passe notre main devant le capteur de luminosité alors le son émis sera grave→fréquence basse).

Quelques indices 

Vous aurez besoin de la fonction tone qui prend deux paramètres :

• la broche où le buzzer est branché
• la fréquence que l’on veut jouer avec le buzzer (exprimée en Hertz)

// la note La (440Hz) jouée sur un buzzer branché sur la broche 8
tone(8, 440);

• Lorsque l’on reçoit beaucoup de lumière sur notre photo-résistance, la fréquence générée devra être proche de $30 000 Hz$ et lorsque la lumière est faible, la fréquence devra être proche de $50 Hz$ ;
• Le buzzer doit avoir une patte connectée à la broche 8 et l’autre au GND.

Quelques conseils

1. N’allez pas regarder la solution sur Internet sinon il n’y a pas de fun ;
2. Prenez toujours les hypothèses qui vous arrangent  ;
3. Seules les notions abordées dans le cours et sur cette page sont nécessaires pour mener à bien ce TP ;
4. Il n’y a pas une mais plusieurs solutions à chaque problème. La meilleure est celle que vous comprenez !

 Bon courage et bonne semaine,

L’équipe du MOOC 

Comment faire si nous possédons un capteur mais n’avons pas sa caractéristique exacte ? Comment feriez-vous pour faire correspondre une valeur analogique lue avec une donnée physique réelle ?

Par exemple, si je vous donne un composant en vous disant “Voilà un capteur de température, je sais qu’il s’alimente en 5V sur telle et telle broches, je sais que le signal de sortie est une tension en fonction de la température mais je suis incapable de te dire quelle est la caractéristique (la courbe de tension en fonction de la température)”.

Nous allons maintenant voir comment résoudre ce problème en voyant une méthode pour étalonner son capteur. Nous allons ainsi nous même déterminer la courbe caractéristique du capteur et déterminer son coefficient liant la température et la tension.

Le capteur utilisé

Pour étudier la méthode que je vous propose ici, nous allons utiliser un capteur de température assez répandu qui se nomme “LM35″. Il existe dans différents boîtiers que voici :

Vous aurez probablement deviné le branchement, il est assez simple. Il suffit de relier +VS au 5V et GND à la masse. Le signal sera ensuite lu sur la broche Vout.

La méthode

La méthode pour caractériser un capteur est assez simple. À l’aide d’une multitude de mesures et d’un appareil témoin, nous allons créer un tableau qui nous servira à calculer la courbe liant la tension à la donnée mesurée (à l’aide d’un tableur). Pour cela, en plus de votre capteur vous aurez besoin d’un appareil de mesure “témoin” qui vous servira de référence. Par exemple le bon vieux thermomètre qui traîne accroché à votre fenêtre fera parfaitement l’affaire !

Prise de mesures

Vous êtes prêts, alors allons-y, commençons à travailler. Reliez le capteur à l’Arduino et l’Arduino à l’ordinateur, de la manière la plus simple possible, comme ceci par exemple :

Ensuite, nous devons récupérer les données envoyées par le capteur de manière régulière (ou rajoutez un bouton et faite des envois lors de l’appui). Pour cela, voici un petit programme sans difficulté qui vous enverra les valeurs brutes ou converties en volts toutes les demi-secondes :

const int capteur = 0; //capteur branché sur la pin analogique 0
float tension = 0.0;
int valeur = 0;

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    valeur = analogRead(capteur);
    tension = (valeur*5.0)/1024;

    Serial.print("Tension : ");
    Serial.print(tension);
    Serial.println(" V");
    Serial.print("Valeur : ");
    Serial.println(valeur);
    Serial.println("---------------------");

    delay(500);
}

Maintenant que tout est prêt, il nous faut un banc de test. Pour cela, préparez une casserole avec de l’eau contenant plein de glaçons (l’eau doit être la plus froide possible). Faites une première mesure avec votre capteur plongé dedans (attention, les broches doivent être isolées électriquement ou alors mettez l’ensemble dans un petit sac plastique pour éviter que l’eau n’aille faire un court-circuit). Faites en même temps une mesure de la température réelle observée à l’aide du thermomètre. Une fois cela fait, relevez ces mesures dans un tableau qui possédera les colonnes suivantes :

• Température réelle (en °C)
• Tension selon Arduino (en V)
• Valeur brute selon Arduino

Quand la première mesure est faite, commencez à faire réchauffer l’eau (en la plaçant sur une plaque de cuisson par exemple). Continuez à faire des mesures à intervalle régulier (tous les 5 degrés voire moins par exemple). Plus vous faites de mesure, plus l’élaboration de la courbe finale sera précise. Voici à titre d’exemple le tableau que j’ai obtenu :

Réalisation de la caractéristique

Lorsque vous avez fini de prendre toutes vos valeurs, vous allez pouvoir passer à l’étape suivante qui est : Calculer la caractéristique de votre courbe !! Sortez vos cahiers, votre calculatrice et en avant ! … Non j’blague (encore que ça ferait un super TP), on va continuer à utiliser notre logiciel tableur pour faire le travail pour nous ! On va donc commencer par regarder un peu l’allure de la courbe. Je vais en faire deux, une symbolisant les valeurs brutes de la conversion du CAN (entre 0 et 1023) en rouge et l’autre qui sera l’image de la tension en fonction de la température en bleu. Nous pourrons alors déterminer deux caractéristiques, selon ce qui vous arrange le plus.

Une fois cela fait, il ne reste plus qu’à demander gentiment au logiciel de graphique de nous donner la courbe de tendance réalisée par ces points. Sous Excel, il suffit de cliquer sur un des points du graphique et choisir ensuite l’option “Ajouter une courbe de tendance…” . Vous aurez alors le choix entre différents types de courbe (linéaire, exponentielle…). Ici, on voit que les points sont alignés, il s’agit donc d’une équation de courbe linéaire, de type $y=ax+b$. Cochez la case “Afficher l’équation sur le graphique” pour pouvoir voir et exploiter cette dernière ensuite.

Voici alors ce que l’on obtient lorsque l’on rajoute notre équation :

Grâce à l’équation, nous pouvons déterminer la relation liant la température et la tension (ou les valeurs du CAN). Ici nous obtenons :

• $y=0.01x–0.0003$ (pour la tension)
• $y=2.056x–0.0707$ (pour les valeurs du CAN)

Le coefficient constant (-0.003 ou -0.0707) peut ici être ignoré. En effet, il est faible (on dit négligeable) comparé aux valeurs étudiées. Dans les équations, x représente la température et y représente la tension ou les valeurs du CAN. On lit donc l’équation de la manière suivante : Tension en Volt égale 0,01 fois la température en degrés celsius. Ce qui signifie que dorénavant, en ayant une mesure du CAN ou une mesure de tension, on est capable de déterminer la température en degrés celsius

Super non ? Par exemple, si nous avons une tension de 300mV, avec la formule trouvée précédemment on déterminera que l’on a 0.3=0.01×Temperature, ce qui équivaut à Temperature=0.3/0.01=30oC . On peut aisément le confirmer via le graphique

Maintenant j’ai trois nouvelles, deux bonnes et une mauvaise… La bonne c’est que vous êtes capable de déterminer la caractéristique d’un capteur. La deuxième bonne nouvelle, c’est que l’équation que l’on a trouvé est correcte… … parce qu’elle est marquée dans la documentation technique qui est super facile à trouver

(ça c’était la mauvaise nouvelle, on a travaillé pour rien !! ) Mais comme c’est pas toujours le cas, c’est toujours bien de savoir comment faire

Adaptation dans le code

Puisque nous savons mesurer les valeurs de notre capteur et que nous avons une équation caractéristique, nous pouvons faire le lien en temps réel dans notre application pour faire une utilisation de la grandeur physique de notre mesure. Par exemple, s’il fait 50°C nous allumons le ventilateur. En effet, souvenez-vous, avant nous n’avions qu’une valeur entre 0 et 1023 qui ne signifiait physiquement pas grand chose. Maintenant nous sommes en mesure (oh oh oh ) de faire la conversion. Il faudra pour commencer récupérer la valeur du signal. Prenons l’exemple de la lecture d’une tension analogique du capteur précédent :

int valeur = analogRead(monCapteur); //lit la valeur

Nous avons ensuite deux choix, soit nous le transformons en tension puis ensuite en valeur physique grâce à la caractéristique du graphique bleu ci-dessus, soit nous transformons directement en valeur physique avec la caractéristique rouge. Comme je suis feignant, je vais chercher à économiser une instruction en prenant la dernière solution. Pour rappel, la formule obtenue était : y=2.056x–0.0707. Nous avions aussi dit que le facteur constant était négligable, on a donc de manière simplifiée y=2.056x soit “la température est égale à la valeur lue divisé par 2.056 (x=y2.056). Nous n’avons plus qu’à faire la conversion dans notre programme !

float temperature = valeur/2.056;

Et voilà ! Si l’on voulait écrire un programme plus complet, on aurait :

int monCapteur = 0; //Capteur sur la broche A0;
int valeur = 0;
float temperature = 0.0;

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    valeur = analogRead(monCapteur);
    temperature = valeur/2.056;

    Serial.println(temperature);

    delay(500);
}

Et si jamais notre coefficient constant n’est pas négligeable ?

Eh bien prenons un exemple ! Admettons qu’on obtienne la caractéristique suivante : y=10x+22 On pourrait lire ça comme “ma valeur lue par le CAN est égale à 10 fois la valeur physique plus 22″. Si on manipule l’équation pour avoir x en fonction de y, on aurait :

Dans le code, cela nous donnerait :

void loop()
{
    valeur = analogRead(monCapteur);
    temperature = (valeur-22)/10;

    Serial.println(temperature);

    delay(500);
}

J’espère que tout cela vous aura intéressé ! Nous en apprendrons bientôt plus à propos des capteurs de température avec la réalisation de l’arduinomètre au cours de la semaine 6.