Département : Génie Électrique

Filière : Ingénierie Électrique (LP)

Rapport du projet traitant

comme sujet :

Étude et comparaison entre deux

capteurs de température LM35 et
CTN avec l’utilisation des logiciels
Matlab et Arduino

Réalisé par :
Encadré par :
 BELAMAMMAR Maroua
 LAOUIDI Maryam  Pr. Med GUERBAOUI

Année Universitaire :
2023/2024

1
2
 Table des matières :
Introduction générale : ................................................................................................ 3
Chapitre 1 : Présentation des capteurs utilisés ........................................................... 4
I. Introduction : ..................................................................................................... 5
II. Les capteurs de températures : ..................................................................... 5
1. Rôle des capteurs de température : ........................................................... 5
2. Caractéristiques des capteurs de température : ......................................... 5
3. Capteur utilisés : ........................................................................................ 6
III. Conclusion : ................................................................................................... 8
Chapitre 2 : Présentation des logiciels utilisés............................................................ 9
I. Introduction : ................................................................................................... 10
II. Les logiciels utilisés : ................................................................................... 10
1. Logiciel Arduino : ...................................................................................... 10
2. Logiciel Matlab : ....................................................................................... 12
III. Conclusion : ................................................................................................. 13
Chapitre 3 : Réalisation et résultat théorique ............................................................ 14
I. Capteur de température CTN : ....................................................................... 15
1. Le montage : ............................................................................................ 15
2. Brochage réel : ......................................................................................... 15
3. Le code Arduino : ..................................................................................... 16
4. Les résultats du moniteur série de l’Arduino IDE : ................................... 16
5. Programme sur Matlab : ........................................................................... 17
6. La courbe obtenue par Matlab : ............................................................... 21
7. Traitement des données de la CTN par Matlab :...................................... 22
II. Capteur de température LM35 :................................................................... 22
1. Le montage : ............................................................................................ 22
2. Brochage réel : ......................................................................................... 23
3. Le code Arduino : ..................................................................................... 23
4. Les résultats du moniteur série de l’Arduino IDE : ................................... 24
5. Programme sur Matlab : ........................................................................... 24
6. La courbe obtenue par Matlab : ............................................................... 29
7. Traitement des données du LM35 par Matlab : ........................................ 29
III. Interprétation des résultats : ........................................................................ 30
Conclusion générale : ............................................................................................... 32

1
 Table des figures :
Figure 1 : Capteur LM35 ............................................................................................. 6
Figure 2 : Tension de sortie du LM35 en fonction de la température .......................... 7
Figure 3 : Capteur CTN .............................................................................................. 8
Figure 4 : Caractéristiques du capteur CTN ............................................................... 8
Figure 5 : Carte Arduino UNO .................................................................................. 10
Figure 6 : Interface Arduino IDE ............................................................................... 11
Figure 7 : Menu fichier de l'Arduino IDE ................................................................... 11
Figure 8 : Les boutons de l'Arduino IDE ................................................................... 12
Figure 9 : Interface de Matlab ................................................................................... 13
Figure 10 : Brochage du capteur CTN avec Arduino UNO ....................................... 15
Figure 11 : Brochage réel de la CTN et Arduino UNO .............................................. 15
Figure 12 : Le code de la CTN sur Arduino IDE ....................................................... 16
Figure 13 : Résultats du moniteur série CTN............................................................ 16
Figure 14 : Courbe CTN ........................................................................................... 21
Figure 15 : Les résultats de la CTN .......................................................................... 22
Figure 16 : Brochage du capteur LM35 avec Arduino UNO...................................... 22
Figure 17 : Brochage réel du LM35 et Arduino UNO ................................................ 23
Figure 18 : Le code du LM35 sur Arduino IDE.......................................................... 24
Figure 19 : Résultats du moniteur série LM35 .......................................................... 24
Figure 20 : Courbe de LM35 ..................................................................................... 29
Figure 21 : Les résultats du LM35 ............................................................................ 29

2
 Introduction générale :

Les capteurs sont des dispositifs électroniques qui mesurent une grandeur
physique telle que la lumière, la température, la pression, l'humidité, la vitesse,
l'accélération, la position, etc. et la convertissent en une sortie électrique,
généralement sous forme de tension ou de courant. Les capteurs sont largement
utilisés dans de nombreuses applications industrielles, automobiles, médicales,
domotiques, et bien d’autres pour surveiller et contrôler les conditions
environnementales et les processus mécaniques. Les capteurs peuvent être actifs ou
passifs, analogiques ou numériques, selon leur fonctionnement et leur sortie.

Notre projet consiste à étudier deux capteurs de température afin de déterminer

leurs caractéristiques et leurs fonctionnements. Par la suite, on va déduire quel est le
capteur le plus fidèle, le plus juste, ainsi que le plus juste. Notre projet va être réalisé
à l’aide des logiciels Matlab et Arduino.

Notre travail est organisé de la manière suivante :

 Le premier chapitre représente les capteurs utilisés pour notre étude, leurs
caractéristiques, mode de fonctionnement, etc.
 Le deuxième chapitre contient une introduction et présentation des logiciels sur
lesquels on a basé notre projet.
 Le troisième chapitre est un résumé de la réalisation du projet, où on présente le
montage utilisé pour chacun des deux capteurs, le code Arduino, le script Matlab,
et la courbe plus les traitements de données par Matlab.

3
Chapitre 1 : Présentation des capteurs
utilisés

4
 I. Introduction :
Dans ce chapitre, nous allons identifier les différents capteurs de température
utilisés et présenter leurs principes de fonctionnement.

II. Les capteurs de températures :

1. Rôle des capteurs de température :

Le rôle d'un capteur de température est de mesurer la température et de
convertir cette mesure en un signal électrique qui peut être utilisé pour contrôler,
surveiller ou enregistrer la température. Les capteurs de température sont largement
utilisés dans de nombreux domaines pour contrôler la température de différents
systèmes et processus, tels que les systèmes de chauffage, les systèmes de
refroidissement, les systèmes de contrôle de l'environnement intérieur, les systèmes
de contrôle de la serre, les systèmes de production alimentaire, etc. Les capteurs de
température peuvent être utilisés pour déterminer la température d'un objet, d'une
substance ou d'un environnement, pour déclencher des alarmes en cas de
température anormale, pour surveiller les changements de température au fil du
temps, pour contrôler la température d'un système en fonction de la température
ambiante.

2. Caractéristiques des capteurs de température :

Les caractéristiques métrologiques clés d'un capteur de température incluent :

 Gamme de températures : La gamme de températures couverte par le capteur,

qui détermine les conditions dans lesquelles le capteur peut être utilisé.

 Précision : La précision décrit la capacité du capteur à mesurer la température de

manière fiable et précise.

 Répétabilité : La répétabilité décrit la capacité du capteur à fournir des mesures

identiques pour des températures identiques.

 Linéarité : La linéarité décrit la capacité du capteur à produire des mesures

proportionnelles à la température.

 Résolution : La résolution décrit la précision minimale avec laquelle le capteur

peut mesurer la température.
5
 Vitesse de réponse : La vitesse de réponse décrit la rapidité avec laquelle le
capteur peut réagir aux changements de température.

 Stabilité : La stabilité décrit la capacité du capteur à maintenir sa précision au fil

du temps.

 Fiabilité : La fiabilité décrit la capacité du capteur à fonctionner de manière fiable

sur une longue période de temps.

Ces caractéristiques dépendent du type de capteur de température utilisé et peuvent

varier en fonction des besoins en matière de précision, de gamme de températures,
de coût.

3. Capteur utilisés :

a. LM35 :
 Définition :

LM35 est un capteur de température

analogique couramment utilisé dans les projets
électroniques pour mesurer la température
ambiante. Il fournit une sortie de tension
proportionnelle à la température mesurée et est
spécifié pour mesurer une plage de température
allant généralement de -55°C à +150°C. La sortie du
Figure 1 : Capteur LM35
capteur change de 10 mV par degré Celsius. Le facteur
d’échelle de sortie du LM35 est de 10 mV/°C et il fournit une tension de sortie de 250
mV à 25°C (voir figure 2).

6
 Figure 2 : Tension de sortie du LM35 en fonction de la température

 Fonctionnement :

LM35 est un capteur de température à sortie analogique, ce qui signifie qu'il

mesure la température et produit un signal analogique proportionnel à la température.
Le principe de fonctionnement du LM35 est basé sur la conversion de la température
en énergie électrique à l'aide d'un matériau à effet thermocouple.
Lorsqu'une température change, elle provoque un changement de potentiel
électrique à l'intérieur du LM35. Ce changement de potentiel est proportionnel à la
température et peut être mesuré en utilisant un amplificateur opérationnel. Le signal
produit par le LM35 peut être converti en une mesure numérique en utilisant un
convertisseur analogique-numérique (ADC).
Le LM35 peut être utilisé avec une tension d'alimentation de 4 à 30 volts et a
une plage de mesure de températures allant de -55°C à +150°C. Il est très précis, avec
une incertitude de ±1°C près de +25°C. De plus, le LM35 est très simple à utiliser et
peut être directement connecté à un microcontrôleur ou à un ordinateur pour lire la
mesure de température.

7
 b. CTN :
 Définition :
La CTN (coefficient de température négatif) est une
thermistance, c'est-à-dire un capteur de température passif. Sa
résistance varie en fonction de la température : elle diminue de façon
uniforme lorsque la température augmente, et inversement.
Concrètement, une CTN est composée d'un matériau semi-
conducteur dont la résistance électrique diminue lorsque la Figure 3 : Capteur CTN
température augmente et vice versa. Cette propriété est exploitée
pour mesurer la température dans diverses applications.
 Fonctionnement :
Le principe de la sonde de température NTC 10K3A1B consiste à mesurer la
résistance et à calculer la température. En effet, la résistance diminue à mesure que
la température augmente. Mais le rapport Résistance / Température n’est pas linéaire.

Figure 4 : Caractéristiques du capteur CTN

III. Conclusion :
Dans ce premier chapitre, nous avons présenté les deux capteurs de températures sur
lesquels nous avons basé notre étude, leurs définitions et leurs modes de
fonctionnement.

8
Chapitre 2 : Présentation des logiciels
utilisés

9
 I. Introduction :
Dans ce chapitre, nous allons présenter les logiciels qu’on a utilisé tout le long de
notre étude et leurs caractéristiques.

II. Les logiciels utilisés :

1. Logiciel Arduino :
Arduino est une plate-forme open-source de prototypage électronique basée sur
du matériel et des logiciels faciles à utiliser. Elle est conçue pour permettre aux
amateurs, aux artistes, aux designers et aux ingénieurs de créer facilement des projets
interactifs. Arduino est composé d'un microcontrôleur programmable, d'un
environnement de développement intégré (IDE) et d'une communauté en ligne active
qui partage des idées et des projets. Les utilisateurs peuvent programmer l'Arduino en
utilisant un langage de programmation simplifié, basé sur le C et le C++, et télécharger
le code sur le microcontrôleur à l'aide d'un câble USB. Arduino est largement utilisé
dans les domaines de l'Internet des objets (IoT), de l'automatisation domestique, de
l'art interactif, de la robotique, de l'éducation, de la recherche et bien d'autres.

L'Arduino Uno est une carte électronique à

microcontrôleur basée sur l'ATmega328P. Elle
dispose de 14 broches d'entrée/sortie numériques, 6
entrées analogiques, un quartz de 16 MHz, une
connexion USB, une prise d'alimentation, un en-tête
ICSP et un bouton de réinitialisation. L'Uno est une
carte populaire pour les débutants et les amateurs en
raison de sa simplicité et de sa facilité d'utilisation. Figure 5 : Carte Arduino UNO

Elle peut être programmée à l'aide du langage de

programmation Arduino et de l'environnement de développement intégré Arduino
(IDE), qui est une application logicielle gratuite disponible pour Windows, Mac et Linux.
L'Uno peut être utilisée pour contrôler divers dispositifs électroniques tels que des
LED, des moteurs, des capteurs et des afficheurs, et peut également communiquer
avec d'autres dispositifs à l'aide de la communication série ou de divers autres
protocoles.

10
 L’interface de l’IDE Arduino et ses composants :

Figure 6 : Interface Arduino IDE

Le cadre numéro 1 : ce sont les options de configuration du logiciel.

Le cadre numéro 2 : il contient les boutons qui vont nous servir lorsque l'on va
programmer nos cartes.
Le cadre numéro 3 : ce bloc va contenir le programme que nous allons créer.
Le cadre numéro 4 : celui-ci est important, car il va nous aider à corriger les fautes
dans notre programme. C'est le débogueur.

Le menu fichier :
Carnet de croquis : Ce menu regroupe les fichiers
que vous avez pu faire jusqu'à maintenant (et s'ils
sont enregistrés dans le dossier par défaut du
logiciel).
Exemples (exemples) : Ceci est important, toute
une liste se déroule pour afficher les noms
d'exemples de programmes existants ; avec ça, vous
pourrez vous aider/inspirer pour créer vos propres
programmes ou tester de nouveaux composants.
Téléverser : Permet d'envoyer le programme sur la
Figure 7 : Menu fichier de l'Arduino IDE
carte Arduino. Nous y reviendrons ;).
Téléverser avec un programmateur : Idem que ci-dessus, mais avec l'utilisation d'un
programmateur (vous n'en n'aurez que très rarement besoin).

11
Préférences : Vous pourrez régler ici quelques paramètres du logiciel. Le reste des
menus n'est pas intéressant pour l'instant, on y reviendra plus tard, avant de
commencer à programmer.

Les boutons :

Figure 8 : Les boutons de l'Arduino IDE

Bouton 1 : Ce bouton permet de vérifier le programme, il actionne un module qui

cherche les erreurs dans votre programme.
Bouton 2 : Charge (téléverse) le programme dans la carte Arduino.
Bouton 3 : Crée un nouveau fichier.
Bouton 4 : Ouvre un fichier.
Bouton 5 : Enregistre le fichier.
Bouton 6 : Ouvre le moniteur série.

2. Logiciel Matlab :
Système interactif de programmation scientifique pour le calcul numérique et la
visualisation graphique, MATLAB est basé sur la représentation matricielle des
données. Disponible sur plusieurs plateformes, cet outil se présente comme un
environnement ouvert et programmable, permettant un gain de productivité important.
Son langage de programmation relativement simple le rend accessible à une
population et un public diversifiés (chercheurs, étudiants, financiers, industriels…).

12
 Interface de Matlab :

Figure 9 : Interface de Matlab

Command Window : est une interface interactive qui facilite l'interaction directe avec
MATLAB pour des tâches diverses, allant de l'exécution de commandes simples à des
activités plus avancées comme le débogage et l'exploration de données.

III. Conclusion :
Dans ce chapitre, on a présenté une simple introduction des logiciels qu’on va
utiliser pour notre étude.

13
Chapitre 3 : Réalisation et résultat
théorique

14
I. Capteur de température CTN :

1. Le montage :

Figure 10 : Brochage du capteur CTN avec Arduino UNO

On connecte une extrémité du capteur CTN à une broche analogique de

l’Arduino utilisé, puis on connecte l’autre extrémité à la masse GND de l’Arduino, ett
en parallèle avec la CTN, on connecte une résistance entre la broche analogique et la
tension d’alimentation Vcc, comme le montre la figure 10.

2. Brochage réel :

Figure 11 : Brochage réel de la CTN et Arduino UNO

15
 3. Le code Arduino :

Ce code Arduino, méticuleusement élaboré au sein de l'IDE, guide le

microcontrôleur dans l'interaction avec le capteur. Les instructions programmées
incluent la lecture des valeurs analogiques du capteur CTN, leur conversion en
données thermiques, et éventuellement l'affichage ou la transmission de ces
informations.

Figure 12 : Le code de la CTN sur Arduino IDE

4. Les résultats du moniteur série de l’Arduino IDE :

Figure 13 : Résultats du moniteur série CTN

16
 5. Programme sur Matlab :
function ctn_matlab()

% Function to perform real-time sensor data analysis

% Create a serial object

s = serial('COM3', 'BaudRate', 9600); % Replace 'COM4' with the correct COM

port

try

% Open the serial port

fopen(s);

fprintf('Serial port opened successfully\n');

% Set up a figure for real-time plotting

figure;

%subplot(2, 1, 1); % Create a subplot for real-time plot

h1 = plot(NaN, NaN);

xlabel('Time');

ylabel('Sensor Value');

title('Real-time Sensor Value Plot from Arduino');

% Read and display the first 100 data points for analysis

data_for_analysis = zeros(1, 100);

for i = 1:100

data = fscanf(s, '%s');

sensorValue = str2double(data);

if ~isnan(sensorValue)

set(h1, 'XData', 1:i, 'YData', data_for_analysis(1:i));

drawnow;

17
 data_for_analysis(i) = sensorValue;

else

fprintf('Invalid sensor value received.\n');

end

end

% Continue with real-time plotting and statistical analysis

subplot(2, 1, 2); % Create a subplot for statistical analysis

stats_analysis(data_for_analysis);

while ishandle(h1)

data = fscanf(s, '%s');

fprintf('Received data from Arduino: %s\n', data);

if contains(data, 'SensorValue:')

valueString = strtrim(strrep(data, 'SensorValue:', ''));

sensorValue = str2double(valueString);

if ~isnan(sensorValue)

set(h1, 'XData', [get(h1, 'XData'), 1], 'YData', [get(h1, 'YData'),

sensorValue]);

drawnow;

% Update data for statistical analysis

data_for_analysis = [data_for_analysis(2:end), sensorValue];

% Perform statistical analysis

stats_analysis(data_for_analysis);

else

fprintf('Invalid sensor value received.\n');

end

18
 end

end

catch exception

fprintf('Error: %s\n', exception.message);

fprintf('Error at line: %d\n', exception.stack.line);

end

% Close the serial connection when done

fclose(s);

delete(s);

clear s;

fprintf('Serial port closed.\n');

end

function stats_analysis(data_for_analysis)

% Function to perform statistical analysis on given data

% Input the true value

fprintf('Enter the true value: ');

value_real = input('');

% Use the provided data for analysis

data = data_for_analysis;

% Calculate mean and standard deviation

mean_value = mean(data);

std_deviation = std(data);

fprintf('Mean: %.4f\n', mean_value);

fprintf('Standard Deviation: %.4f\n', std_deviation);

19
 % Calculate relative fidelity

fidelity_relative = (std_deviation / mean_value) * 100;

fprintf('Relative Fidelity: %.2f%%\n', fidelity_relative);

% Calculate confidence intervals

interval_68 = calculate_confidence_interval(std_deviation, mean_value, 68.0);

interval_95 = calculate_confidence_interval(std_deviation, mean_value, 95.0);

interval_99_5 = calculate_confidence_interval(std_deviation, mean_value, 99.5);

fprintf('Confidence Interval at 68%%: +/- %.4f\n', interval_68);

fprintf('Confidence Interval at 95%%: +/- %.4f\n', interval_95);

fprintf('Confidence Interval at 99.5%%: +/- %.4f\n', interval_99_5);

% Calculate accuracy and precision

accuracy = calculate_accuracy(mean_value, value_real);

precision = calculate_precision(std_deviation, value_real);

fprintf('Accuracy: %.2f%%\n', accuracy);

fprintf('Precision: %.2f%%\n', precision);

end

function interval = calculate_confidence_interval(std_deviation, mean_value,

confidence_level)

% Function to calculate confidence interval

z_score = 0;

if confidence_level == 68.0

z_score = 1.0;

elseif confidence_level == 95.0

z_score = 1.96;

elseif confidence_level == 99.5

20
 z_score = 2.807;

else

fprintf('Unsupported confidence level.\n');

return;

end

interval = z_score * (std_deviation / sqrt(length(mean_value)));

end

function justness = calculate_accuracy(mean_value, value_real)

% Function to calculate accuracy

justness = abs((mean_value - value_real) / value_real * 100);

end

function precision = calculate_precision(std_deviation, value_real)

% Function to calculate precision

precision = (std_deviation / value_real) * 100;

end

6. La courbe obtenue par Matlab :

Figure 14 : Courbe CTN

21
 7. Traitement des données de la CTN par Matlab :

Figure 15 : Les résultats de la CTN

La valeur de l’écart type : 0.0046

La valeur vraie : 20

La Fidélité Relative : 0.02 %

L’intervalle de 68% : +\ -0.0046

L’intervalle de 95% : +\ -0.0090

L’intervalle de 99.5% : +\ -0.0129

La justesse : 4.65%

La précision : 0.02%

II. Capteur de température LM35 :

1. Le montage :

Figure 16 : Brochage du capteur LM35 avec Arduino UNO

22
 Pour connecter le capteur de température LM35 à l'Arduino Uno, on relie la broche
GND du LM35 à la masse (GND) de l'Arduino, la broche VCC du LM35 à l'alimentation
5V de l'Arduino, et la broche de signal (sortie) du LM35 à une broche analogique de
l'Arduino, telle que A0 dans le cas de la figure précédente. Cette configuration permet
d'établir une connexion correcte pour mesurer la température à l'aide du LM35.

2. Brochage réel :

Figure 17 : Brochage réel du LM35 et Arduino UNO

3. Le code Arduino :
Ce programme Arduino, soigneusement conçu à l'intérieur de l'environnement de
développement intégré (IDE), dirige le microcontrôleur dans l'interaction avec le
capteur. Les instructions programmées comprennent la capture précise des données
analogiques provenant du capteur CTN, leur conversion en informations thermiques,
et éventuellement la visualisation ou la transmission de ces données.

23
 Figure 18 : Le code du LM35 sur Arduino IDE

4. Les résultats du moniteur série de l’Arduino IDE :

Figure 19 : Résultats du moniteur série LM35

5. Programme sur Matlab :

function lm35_matlab()

% Fonction pour effectuer une analyse en temps réel des données du capteur LM35

% Créer un objet série

s = serial('COM3', 'BaudRate', 9600); % Remplacez 'COM3' par le bon port COM

try

24
% Ouvrir le port série

fopen(s);

fprintf('Port série ouvert avec succès\n');

% Configurer une figure pour le tracé en temps réel

figure;

h1 = plot(NaN, NaN);

xlabel('Temps');

ylabel('Valeur du capteur');

title('Tracé en temps réel de la valeur du capteur LM35 depuis Arduino');

% Lire et afficher les 100 premiers points de données pour l'analyse

data_for_analysis = zeros(1, 100);

for i = 1:100

voltage = fscanf(s, '%f');

if ~isnan(voltage)

set(h1, 'XData', 1:i, 'YData', data_for_analysis(1:i));

drawnow;

data_for_analysis(i) = voltage;

else

fprintf('Tension du capteur invalide reçue.\n');

end

end

% Continuer avec le tracé en temps réel et l'analyse statistique

subplot(2, 1, 2);

stats_analysis(data_for_analysis);

25
while ishandle(h1)

voltage = fscanf(s, '%f');

fprintf('Données reçues depuis Arduino : %.4f volts\n', voltage);

if ~isnan(voltage)

set(h1, 'XData', [get(h1, 'XData'), 1], 'YData', [get(h1, 'YData'), voltage]);

drawnow;

% Mettre à jour les données pour l'analyse statistique

data_for_analysis = [data_for_analysis(2:end), voltage];

% Effectuer une analyse statistique

stats_analysis(data_for_analysis);

else

fprintf('Tension du capteur invalide reçue.\n');

end

end

catch exception

fprintf('Erreur : %s\n', exception.message);

fprintf('Erreur à la ligne : %d\n', exception.stack.line);

end

% Fermer la connexion série à la fin

fclose(s);

delete(s);

clear s;

fprintf('Port série fermé.\n');

end

26
function stats_analysis(data_for_analysis)

% Fonction pour effectuer une analyse statistique sur les données

% Entrer la valeur réelle

fprintf('Entrez la valeur réelle : ');

value_real = input('');

% Utiliser les données fournies pour l'analyse

data = data_for_analysis;

% Calculer la moyenne et l'écart-type

mean_value = mean(data);

std_deviation = std(data);

fprintf('Moyenne : %.4f volts\n', mean_value);

fprintf('Écart-type : %.4f volts\n', std_deviation);

% Calculer la fidélité relative

fidelity_relative = (std_deviation / mean_value) * 100;

fprintf('Fidélité relative : %.2f%%\n', fidelity_relative); % Calculer les intervalles de

confiance

interval_68 = calculate_confidence_interval(std_deviation, mean_value, 68.0);

interval_95 = calculate_confidence_interval(std_deviation, mean_value, 95.0);

interval_99_5 = calculate_confidence_interval(std_deviation, mean_value, 99.5);

fprintf('Intervalle de confiance à 68%% : +/- %.4f volts\n', interval_68);

fprintf('Intervalle de confiance à 95%% : +/- %.4f volts\n', interval_95);

fprintf('Intervalle de confiance à 99.5%% : +/- %.4f volts\n', interval_99_5);

% Calculer l'exactitude et la précision

accuracy = calculate_accuracy(mean_value, value_real);

precision = calculate_precision(std_deviation, value_real);

27
fprintf('Exactitude : %.2f%%\n', accuracy);

fprintf('Précision : %.2f%%\n', precision);

end

function interval = calculate_confidence_interval(std_deviation,

mean_value,confidence_level)

% Fonction pour calculer l'intervalle de confiance

z_score = 0;

if confidence_level == 68.0

z_score = 1.0;

elseif confidence_level == 95.0

z_score = 1.96;

elseif confidence_level == 99.5

z_score = 2.807;

else

fprintf('Niveau de confiance non pris en charge.\n');

return;

end

interval = z_score * (std_deviation / sqrt(length(mean_value)));

end

function justness = calculate_accuracy(mean_value, value_real)

% Fonction pour calculer l'exactitude

justness = abs((mean_value - value_real) / value_real * 100);

end

function precision = calculate_precision(std_deviation, value_real)

% Fonction pour calculer la précision

28
precision = (std_deviation / value_real) * 100;

s = instrhwinfo('serial');

s.AvailableSerialPorts

end

6. La courbe obtenue par Matlab :

Figure 20 : Courbe de LM35

7. Traitement des données du LM35 par Matlab :

Figure 21 : Les résultats du LM35

La valeur de l’écart type : 0.7933

La valeur vraie : 19

La Fidélité Relative : 3.77 %

L’intervalle de 68% : +\ - 0.7933

29
 L’intervalle de 95% : +\ - 1.5548

L’intervalle de 99.5% : +\ - 2.2268

La justesse : 10.75%

La précision : 4.18%

III. Interprétation des résultats :

Pour la CTN, on observe un écart type relativement bas, mesuré à 0.0046, ce
qui témoigne d'une dispersion restreinte des valeurs par rapport à la moyenne. Cette
faible variabilité suggère une cohérence remarquable dans les mesures obtenues. De
plus, la fidélité relative de seulement 0.02% indique une précision extrêmement élevée
par rapport à la valeur de référence de 20. Cette fidélité relative minime signifie que
les mesures de la CTN sont très fidèles à la réalité, soulignant ainsi la fiabilité et la
précision du capteur dans son évaluation de la température.
Cependant, en ce qui concerne le LM35, une observation différente se dégage.
Son écart type plus élevé, évalué à 0.7933, signale une dispersion plus marquée des
mesures par rapport à la moyenne. Cette variabilité accrue suggère une amplitude
plus importante dans les résultats obtenus avec le LM35. De plus, la fidélité relative
est également plus élevée, s'établissant à 3.77%. Cette proportion plus importante
indique une précision relativement moindre par rapport à la valeur réelle de 19.
En résumé, l'analyse comparative des capteurs CTN et LM35 a révélé plusieurs
observations significatives. La CTN se distingue par un faible écart type de 0.0218,
signalant une dispersion limitée des mesures autour de la moyenne. La fidélité relative
exceptionnellement basse de 0.09% suggère une précision élevée par rapport à la
valeur réelle de 24. Ces caractéristiques font de la CTN un choix privilégié pour des
applications nécessitant une mesure stable et précise.

En revanche, le capteur LM35 présente un écart type plus élevé de 0.7933,

soulignant une dispersion plus importante des mesures. La fidélité relative de 3.77%
indique une précision relativement inférieure par rapport à la valeur réelle de 19. Bien
que le LM35 offre des mesures utiles, sa variabilité accrue peut nécessiter des
ajustements dans certaines applications où une précision élevée est cruciale.

En fonction de ces résultats, le choix entre la CTN et le LM35 devrait être guidé
par les exigences spécifiques de l'application. La CTN se démarque pour sa stabilité

30
et sa précision, tandis que le LM35 peut être plus adapté à des situations où une légère
variabilité est acceptable. Ces conclusions soulignent l'importance de sélectionner le
capteur en fonction des critères de performance requis pour une application
particulière.

31
 Conclusion générale :

Dans son ensemble, ce projet s'est concentré sur l'exploration et l'application

de capteurs de température, en mettant particulièrement l'accent sur la CTN et le
LM35. L'objectif principal était de mesurer, analyser et comparer les performances de
ces deux capteurs dans un contexte d'acquisition de données en temps réel.

La première phase du projet a impliqué la mise en place de l'environnement de

mesure en utilisant les plateformes Arduino et MATLAB. Le code Arduino a été
développé pour permettre la lecture des capteurs, tandis que le code MATLAB a été
conçu pour l'analyse en temps réel des données, incluant des métriques statistiques
telles que la fidélité relative, l'écart type, et d'autres indicateurs.

Les résultats obtenus ont révélé des caractéristiques distinctes pour la CTN et
le LM35. La CTN a démontré une stabilité élevée avec un écart type faible, indiquant
une dispersion limitée des mesures. Sa fidélité relative exceptionnellement basse a
souligné une précision élevée par rapport à la valeur vraie. En revanche, le LM35 a
présenté une variabilité plus importante dans ses mesures, avec un écart type plus
élevé et une fidélité relative relativement supérieure.

Cette comparaison a permis de tirer des conclusions significatives pour guider

le choix des capteurs en fonction des exigences spécifiques d'une application. La CTN
pourrait être privilégiée dans des situations nécessitant une précision élevée et une
faible variabilité, tandis que le LM35 pourrait être adapté à des contextes où une légère
variabilité est acceptable.

En somme, ce projet a permis d'acquérir des compétences pratiques dans le

domaine de la mesure et de l'analyse de capteurs de température, offrant une
compréhension approfondie des caractéristiques et des performances de deux
capteurs couramment utilisés. Ces connaissances peuvent être étendues et adaptées
à d'autres projets et applications nécessitant des mesures thermiques précises.

32