Avant de commercer cet article, je tiens à remercier Amaury qui m’a permis de publier cet article sur son site. 🙂

Je découvre actuellement l’électronique et la programmation entre  LabVIEW et Arduino et je tiens à partager certains résultats avec vous. Certaines notions abordées ne seront pas forcément poussées ou assez détaillées pour des lectures ou lectrices plus expérimenté(e)s.

Théorie de mesure de distance Lidar

Lidar est l’acronyme anglais de light detection and ranging qui est une technique qui permet de mesurer des distances allant de quelques centimètres à la distance Terre-Lune. Le lidar Garmin utilisé ici, génère un train d’onde électromagnétique cohérente (un faisceau laser InfraRouge) de longueur d’onde λ de 905 nm. Les trains d’onde sont envoyés à une fréquence comprise entre 10 à 20 kHz (à ne pas confondre avec la fréquence propre de l’onde du laser IR) d’après les datasheet. Les trains d’ondes se réfléchissent sur la cible visée par le capteur. Une partie de la lumière du laser revient sur le capteur. Une photodiode placée dans le Lidar et sensible dans la plage de longueur d’onde des IR reçoit l’onde réfléchie. L’écart de temps entre le départ d’un train d’onde et son retour est mesuré par le capteur. Cet écart de temps est proportionnel à la distance parcourue par l’onde. Cette technologie de mesure est communément appelée Time of Flight.

Le matériel utilisé pour la réalisation

Nota : un clavier et une souris seront très certainement nécessaires pour naviguer sur LattePanda.

Le Montage global

Le schéma suivant a été réalisé sur le logiciel libre Fritzing. N’ayant pas trouvé de modèle de LattePanda dans la librairie Fritzing, il a donc été représenté par sa carte Arduino qu’il intègre. Un schéma du LattePanda est donné après.

Figure 1 Schéma Global de la mesure Lidar (à l’aide du logiciel gratuit Fritzing)

L’intégration des différents éléments a été faite à l’aide d’un vieux jeu mécanos.

LattePanda

Le modèle de  LattePanda utilisé est le 4 GB/64 GB sous Windows 10. Ce modèle suffit pour faire tourner un LabVIEW 2014 (https://www.gotronic.fr/art-carte-lattepanda-4-gb-64-gb-dfr0419-24792.htm ). LattePanda sera très utile car il intègre une carte Arduino Leonardo et ses E/S associées. A l’aide des entrées et sorties numériques (0-5V), il sera possible de piloter le moteur pas à pas, le laser et d’acquérir le signal du Lidar. Le LattePanda est enfaîte un petit ordinateur d’instrumentation très compacte et assez puissant. Le projet n’utilise ici qu’une petite partie de sa capacité. Pour plus de détails sur LattePanda, le lecteur pourra se référer à l’article : LattePanda – Première mise en route

Le schéma ci-dessous reprend les principales E/S :

Figure 2 E/S LattePanda 4GB/64GB (https://www.lattepanda.com)

Le moteur Pas à Pas

Le moteur Pas à Pas bipolaire est contrôlé par un Driver Pololu (A4988). Le schéma ci-après (d’après le site Pololu qui commercialise le Driver) permet de connecter le moteur et le Driver. La puce du Driver est alimentée en 5 V par la carte Arduino du LattePanda. Ce driver a été choisi car il est facilement pilotable à partir des E/S digitales du Arduino, qui seront contrôlées par le logiciel ; lequel qui sera abordé après.

Figure 3 Schéma de fonctionnement du Drive couplé au moteur Pas à Pas (bipolaire)

Pour connecter correctement le moteur pas à pas au driver on pourra suivre le tableau suivant :

Figure 4 Schéma du moteur Pas à Pas (14HM11-0404S) d’après datasheet Go Tronic

Il est conseillé de relier la masse de l’alimentation du moteur à la masse du circuit afin d’éviter de le moteur ne grésille. Un petit régulateur LM7815 (15 V) permet de limiter la tension en entrée. Pour ma part j’ai utilisé deux piles de 9 V. En sortie du régulateur il vaut mieux ne pas oublier de limiter le courant à l’aide d’une résistance de charge. Le moteur consomme 400 mA par phase. Pour limiter le courant j’ai choisi de mettre en parallèle 4 résistances de 2 kΩ de 1/4 W qui forment une résistance 500 Ω supportant 1 W. Avec ce montage, le moteur ne chauffe et a assez de puissance pour réaliser ses pas. Un potentiomètre présent sur le driver permet de réguler la tension. Le réglage du courant limite est disponible dans la vidéo disponible en suivant de lien (https://www.youtube.com/watch?v=89BHS9hfSUk). Pololu préconise de régler le courant limite à l’aide du réglage du VREF et non en entrée comme cela a été fait ici.

• Une fois le montage du moteur réalisé, un test du moteur peut être réalise. Pour cela, la Pin STEP du driver peut être connecté au 5V délivré par l’Arduino. Le moteur est censé faire un pas. Sinon, revérifier le schéma de montage.

Les entrées MS1, MS2 et MS3 permettent de réduire le Pas, c’est-à-dire de gagner en précision angulaire. Le tableau ci-dessous affiche les niveaux à utiliser sur les pins en fonctions de la résolution du pas.

Figure 5 Tableau de résolution des pas d’après le site Pololu

Dans le cas présent, un pas complet est de 0,9°, un demi-pas en vaudra la moitié et ainsi de suite. Dans le présent projet, il n’est pas possible de descendre en dessous du demi-pas.

Nota important: il est fortement déconseillé de déconnecter le moteur du driver quand le moteur est en fonctionnement car le Driver peut-être endommagé. Il faudra couper l’alimentation du moteur pour effectuer des changements de postions (si besoin) sur les 4 fils du moteur pas à pas.

Le Lidar

Pour fonctionner le Lidar doit être alimenté en 5 V. L’alimentation 5 V de l’Arduino du LattePanda convient parfaitement. L’acquisition de la mesure de distance est lue en largeur d’impulsion (PWM) sur le fil jaune. Les datasheet préconisent l’utilisation d’une résistance de 1KΩ qui est reliée entre le fil de sortie de la mesure et la masse comme ci-dessous :

Figure 6 Schéma de câblage du lidar en acquisition de mesure en PWM (d’après datasheet Gramin)

Concernant les aspects métrologiques du capteur, la portée maximale du Lidar est de 40 mètres. Sa résolution est de 1 cm.

L’incertitude de mesure du Lidar Lite V3,  entre 0 et 5m est de ± 2.5cm et ± 10 cm au delà.

En sortie de mesure en largeur d’impulsion, la sensibilité est de 10 µs/cm. Cette valeur est à retenir pour comprendre la partie acquisition du signal du logiciel.

Le Laser de visée

Le laser est utile ici afin d’avoir un repère visuel sur l’orientation du Lidar. Le laser est du même type qu’utilisé pour les pointeurs laser de présentation (diode laser). Dans le cas présent, un laser d’alignement de 1 mW (λ = 650 nm) de couleur rouge a été utilisé. Il est alimenté en 5V par une entrée digitale de carte Arduino activable à partir du logiciel.

Attention aux yeux ! Le laser concentre l’énergie sur une surface très petite et a pour conséquence d’être nocif pour l’œil.

L’utilisateur est responsable de sa sécurité mais également celle des personnes autour !

Le logiciel/programme

Pour piloter les instruments (Lidar, moteur, laser) le logiciel LabVIEW 2014 est utilisé. Le but n’est pas de faire la présentation ni la promotion de ce logiciel mais de tenter d’expliquer comment utiliser certaines briques LINX. Si LabVIEW n’est pas utilisé, il sera quand même possible de piloter les instruments via un programme développé sur l’IDE Arduino. La suite de l’article pourra paraître obscure pour les personnes non initiées à LabVIEW; je m’en excuse par avance. Cependant, un petit effort a été fait pour que le code soit compris des personnes non initiées à LabVIEW.

Des briques (ou VI) de code LabVIEW ont été développées afin de faciliter grandement la compatibilité entre des cartes Arduino et LabVIEW. Pour utiliser les briques de codes LINX, la bibliothèque LINX côté LabVIEW doit avoir été installée préalablement dans VI Pack Manager (logiciel qui permet de charger des ToolKit ou librairies de programme).

Chargement des librairies

Avant de compiler le code, il faut charger les bibliothèques. Pour charger les bibliothèques, aller sur l’onglet Tool\MakerHub\LINX\Generate Firmware Librairies :

Et mettre en cible : C:\Program Files\Arduino\Libraries

Les librairies sont donc maintenant chargées et opérationnelles.

Configuration du type de carte

Avant de compiler le code, il faudra configurer le type de carte (Mega, Leonardo) et le type de liaison. Dans ce projet avec LattePanda, la carte Arduino Leonardo est utilisée sur le port COM 4. Dans LabVIEW cliquez dans l’onglet Tool puis \MakerHub\LINX\LINX Firmware Wizard… il faut configurer les champs à l’aide des informations mentionnées plus haut.

TEST simple avec une LED

Pour vérifier que la carte fonctionne correctement, l’exemple du pilotage d’une LED pourra être réalisé (onglet HELP/Find Example…). L’exemple est prêt à être utilisé et ne nécessite que la mise en place d’une LED en série avec une résistance de 220 Ω reliées au LattePanda.

Mettre le port COM 4 (normalement) et configurer la pin du Arduino sur laquelle est reliée l’anode de la LED (la patte la plus longue) et ne pas oublier la résistance de 220 Ω en série 😉 . Puis relier la résistance à la masse et lancer le programme (flèche blanche).

Si la LED clignote quand le bouton est pressé, c’est gagné. Passer aux étapes suivantes. Sinon, il faut trouver la raison de cette malchance.

Ne pas hésiter à reconfigurer la carte car il arrive (trop) souvent que cela saute au bout de 3 à 4 compilations. Par exemple, il vaut mieux arrêter proprement la boucle avec un bouton « stop » placé dans la boucle While plutôt que de stopper le programme avec le bouton rouge de LabVIEW.

L’IHM (côté « Face Avant » de LabVIEW)

L’IHM qui permet à l’utilisateur de contrôler les instruments pourra ressembler fortement à celle présentée ci-dessous.

Les configurations des Pins et du port sont situées à gauche.

Le bouton « Motor ON » permet d’activer le driver sur la Pin ENABLE (Driver).

Le bouton « Left » permet d’activer la Pin STEP (Driver)  et faire faire un pas au moteur.

Le bouton « Right »agit comme le bouton « Left » mais active la pin DIR (Driver) à l’état haut et permet de changer de sens de rotation.

Un bouton « Laser » permet d’activer le laser de visée.

Un bouton STOP permet d’arrêter l’exécution proprement et d’arrêter le moteur (ENABLE) et le Laser.

Trois types d’indicateurs sont présents : numérique (format chaîne de caractère), une barre de remplissage, et un graphe déroulant.

Un contrôleur barre graphe permet de passer au pilotage Pas par Pas (un clique sur LEFT ou RGTH = 0,9°) ou active la vitesse constante (comme sur la vidéo du début de l’article).

Pour le lecteur non initié à LabVIEW, la « face avant » est la partie visible finale du programme disponible pour l’utilisateur.

Le code est développé dans une seconde fenêtre appelée « Diagramme ». Et c’est la partie de développement du Diagramme que nous allons maintenant aborder.

Nota : un Crtl+E permet de permuter rapidement rentre la face avant et le diagramme.

La structure (côté diagramme)

La structure générale du programme est la suivante :

Figure 7 Structure générale du programme dans un boucle While

Le code source ne sera pas disponible dans cet article mais les principales briques seront détaillées pour arriver facilement au résultat. 🙂

Lecture de la valeur de la distance du Lidar

Le Lidar Garmin Lite V3 admet deux sorties de données pour la lecture des mesures : I2C ou PWM. La lecture en modulation de largeur d’impulsion est apparue comme le plus simple du point de vue du soft. Un VI LINX permet de réaliser cette mesure rapidement contre plusieurs VI pour la communication en I2C.

Dans la boucle While cadencée à 50 ms, la mesure du Lidar est effectuée à l’aide du VI « Lecture de la largueur d’impulsion » :

L’entrée DO Channel est connectée et la valeur de la Pin 0 de la carte Arduino est rentrée (cf Figure 8 ci-dessous).

Un tableau général de configuration des Pins d’E/S pourra être créé en amont de la boucle While comme ceci :

La valeur en sortie du VI n’est pas en cm mais en largeur d’une impulsion (µs), qui est proportionnelle à la distance mesurée en cm par le lidar. Afin de lire et d’afficher une valeur en cm, il faut diviser les valeurs en sortie du VI par une constante valant 10 pour obtenir une mesure de longueur (en cm). Cette constante est la sensibilité (en µs/cm) du capteur abordé précédemment que l’on peut retrouver dans la documentation du Lidar Lite V3 (page 4, §Mode Pin Control).

Une moyenne glissante pourra être développée afin d’obtenir une mesure plus stable et plus juste à l’aide des registres à décalage (flèches oranges sur les bords de la boucle While). L’inconvénient de cette technique est qu’il faudra attendre n fois le nombre de points moyennés, pour obtenir le résultat. Si l’on choisit de moyenner sur 10 points et que le temps du cadencement est de 500 ms, alors le résultat sera juste au bout de 5 secondes. Ne pas oublier d’initialiser les registres à décalage à zéro. Différents types d’indicateurs pourront être placés en face avant comme ci-dessous :

Figure 9 Moyenne glissante (côté diagramme/code) et exemples d’indicateurs en face avant

Comme le Lidar affiche une incertitude de ± 2.5 cm et une résolution de 1 cm, il a été choisi de n’afficher que des valeurs entières arrondies au centimètre.

VI de contrôle du Driver et du moteur

Un VI « écrire sur des E/S digitales » permet d’activer les sorties de l’Arduino du LattePanda afin de piloter le Driver.

La fonction suivante a été construite comme ci-après :

Cette fonctionnalité permet de prendre, en entrée, un tableau de booléens (ordres des boutons pressés en face avant) et d’activer les E/S correspondantes.

• La première entrée (en partant du haut) de la fonction « Construire un tableau» est reliée au bouton « MOTOR ON » et agit sur la Pin « ENABLE » du Driver. Ce bouton permet vraisemblablement d’activer l’alimentation du driver et du moteur.
• La seconde entrée permet de gérer la direction du moteur. Le fil (vert) est relié au bouton « RIGHT » de mon interface afin d’active la Pin « DIR » du driver. Le moteur tourne ainsi dans le sens horaire.
• La troisième entrée active la pin « STEP » du driver et permet d’effectuer un Pas de 0,9° (avec les entrées du driver MS1=MS2=MS3=0=GND). Le moteur effectue un pas par changement de niveau de l’état bas à l’état haut. Cette entrée est active si le bouton « LEFT » OU le bouton « RIGHT » est activé. Nous verrons ensuite comment faire tourner le moteur à vitesse constante.
• La quatrième entrée active le laser. Un laser de visée peut fonctionner qu’avec une tension de 5V et ne consomme que quelques milliampères. Il est souhaitable pour la sécurité des personnes, que le bouton « STOP » qui arrête le programme, puisse stopper l’émission du laser à la fin de la manip en même temps. Pour cela on pourra mettre une boucle conditions comme ci-dessous :

Il pourra être fait de même avec l’arrêt du moteur (« MOTOR ON ») à la fin de l’exécution du programme.

• Les cinquième, sixième et septième entrées activent les Pins MS1, MS2 et MS3 du driver et permettent de gagner en précision d’angle (jusqu’au demi pas ici).

Afin de faire fonctionner le moteur à vitesse constante, la fonctionnalité suivante a été développée :

Lorsqu’un booléen (bouton) active la structure « Cas », le VI « écrire un signal carré » est activé avec une fréquence nulle et d’une durée nulle sur la pin STEP. Cette fonctionnalité m’a permis de faire fonctionner le moteur à vitesse constante. Dans ce cas, la vitesse est fonction du temps de cadencement de la boucle (réglée à 50 ms). A l’heure où est écrit cet article, il existe surement de meilleures solutions, notamment avec le VI « PWM Set Duty Cycle »:

Mais cela n’a pas fonctionné comme il était souhaité lors du test.

A la suite de ces nombreux réglages et bidouillages, le programme doit pouvoir se lancer (flèche blanche non brisée). Si cela n’est pas le cas, résoudre les erreurs unes à unes.

Il fortement probable que rien ne fonctionne du premier coup, ou qu’à moitié, il est alors conseillé, dans un premier temps, de vérifier les branchements (alimentation) des organes dysfonctionnant.

L’utilisateur pourra jouer avec les différents types d’actions mécaniques pour contrôler le moteur (clique droit sur un bouton) :

Résultats en images :

Figure 10 Interface de la mesure de distance (Windows n’est pas à l’heure ^_^ )

J’espère que ce projet a pu continuer d’éveiller votre curiosité et a pu vous aider dans vos futurs développements !

Sources :

• Site Pololu (https://www.pololu.com/product/1182 )
• Site GO Tronic
• https://www.lattepanda.com
• Ressources LINX : http://sine.ni.com/nips/cds/view/p/lang/fr/nid/212478
• Forum LINX : https://www.labviewmakerhub.com/doku.php?id=libraries:linx:start
• Datasheet Lidar Garmin lite V3 : https://static.garmin.com/pumac/LIDAR_Lite_v3_Operation_Manual_and_Technical_Specifications.pdf
• LabVIEW – 4e édition – Programmation et applications – Introduction à LabVIEW NXG, Collection : Technique et ingénierie, Dunod, Parution : août 2018,Francis Cottet, Luc Desruelle, Michel Pinard

• The Art of electronic, Third edition, Paul Horowitz et Winfield Hill

Cet article Mesure Lidar rotatif embarqué sur LattePanda et piloté par LabVIEW (LINX) est apparu en premier sur Electronique et Informatique.

1 – Le conditionneur pour Pt500

Les thermorésistances à fil de platine sont des capteurs de température de qualité offrant une bonne répétabilitée et une grande étendue de mesure (possibilité de mesurer des températures très faibles, de l’ordre de quelques kelvins). Malgré leur coût élevé, ces sondes de température sont très répandues pour les applications de mesure de précision.

D’une manière générale, la résistance électrique des métaux augmente avec la température. En effet, la température se traduit par la vibration des atomes constitutifs de la matière autour de leur position d’équilibre. Plus la température est élevée, plus l’amplitude de vibration est grande.

Le modèle communément utilisé pour décrire les métaux est le suivant: on considère un réseau de noyaux atomiques aux positions d’équilibre fixes baignant dans une « mer d’électrons ». C’est cette mer d’électrons qui permet aux métaux de conduire l’électricité. Une forte amplitude de vibration des atomes, donc des noyaux, va rendre le mouvement des électrons de conduction plus difficile: la résistance électrique augmente.

La loi de variation de résistance des métaux est la suivante:

R(\theta ) = R_0\cdot (1 + \alpha \cdot \theta + \beta \cdot \theta^2 + \gamma \cdot \theta^3 + ...)

Thêta correspond à la température du fil en °C et R0 correspond à la résistance du fil à 0°C. La finesse du modèle peut être adaptée à l’application de la sonde et à la précision recherchée. Pour le platine les coefficients sont les suivants:
\alpha = 3.9083\cdot 10^{-3} K^{-1}
\beta = -5.775\cdot 10^{-7} K^{-2}
\gamma = -4.183\cdot 10^{-12} K^{-3}
Ma sonde est une Pt500. Cela signifie qu’elle utilise un fil de platine et que sa résistance à 0°C est 500 Ohms. Le conditionneur que je propose peut bien sûr être modifié pour utiliser des Pt100, PT1000 et autres sondes résistives comme les thermistances (CTN et CTP à oxydes métalliques). Le traitement du signal devra être adapté en conséquence.

La mesure de la température se résume donc à une mesure de résistance. Il est possible d’appliquer simplement la loi d’Ohm: faire circuler un courant dans la sonde et mesurer la tension à ces bornes. Cette méthode d’apparence simpliste offre de bons résultats. Cependant, le principal inconvénient de cette méthode est la présence d’un mode commun. En claire, la tension correspondant à une température nulle n’est pas 0V mais U/R0. Pour pallier à cet inconvénient, j’ai préféré utiliser un pont de Wheatstone.

Le pont de Wheatstone est basé sur le principe du diviseur de tension. Il est très utilisé pour les applications de mesure, notamment le conditionnement de jauges de déformation résistives. L’idée est de réaliser un pont diviseur de référence avec des résistances fixes de précision et un autre contenant le capteur, puis de mesurer la tension différentielle entre les deux points milieux des ponts. Si les résistances fixes du pont sont choisies judicieusement, il est possible d’annuler le mode commun. S’il n’y a qu’un capteur dans le pont, le montage est dit « quart de pont ». Il est possible d’augmenter la sensibilité du pont en mettant deux ou quatre capteurs (montages demi-pont ou pont complet) à condition d’avoir des capteurs dont la résistance varie dans des directions opposées pour une même stimulation.

Pour conditionner ma Pt500, j’ai réalisé un montage quart de pont avec des résistances fixes de 500 Ohms (deux 1k en parallèle). Ainsi à 0°C, la tension de sortie du pont est égale à E/2 – E/2 = 0V (où E est la tension d’alimentation du pont)!

La mesure de la tension différentielle est confiée à un amplificateur d’instrumentation: l’INA126. Basiquement, il s’agit d’un montage soustracteur de tension. À la différence d’un montage traditionnel mettant en jeu un seul amplificateur opérationnel, l’amplificateur d’instrumentation présente une très grande impédance sur ses deux entrées (environ 10^12 Ohms). Pour cette application, l’INA126 peut avantageusement être remplacé par son petit frère l’INA125 qui propose en plus une référence de tension pour alimenter le pont. Le gain de l’amplificateur d’instrumentation est fixé par une résistance externe: G = 5 + 80k/Rg. Je ne l’ai pas connectée, ce qui m’offre un gain de 5 qui convient parfaitement à mon application.

L’INA126 est alimenté comme tous les composants du montage par le 5V issu de l’alimentation. On se place en limite de fonctionnement de l’amplificateur (tension mini d’alimentation: +/- 1.35V soit 2.70V). Comme tous les amplificateurs opérationnels (à part la série des LM124, 224 et 324) il a besoin d’une alimentation symétrique, ou au moins d’une partie négative et d’une partie positive, pour pouvoir amplifier des signaux tantôt positifs, tantôt négatifs. L’INA126 à un fonctionnement un peu particulier: il a besoin d’une tension alimentation et d’une tension de référence. La sortie de l’INA126 est alors: dans la mesure où Vout est inférieure à la tension d’alimentation.

Dans une application classique, l’INA126 serait alimenté en +15V / -15V avec Vref = 0V. Ainsi, il pourrait amplifier tous les signaux positifs ou négatifs qui ne feraient pas saturer la sortie. Dans mon montage, je l’ai alimenté en +5V / 0V avec Vref fixé à 1V par un potentiomètre bufferisé par un LM124 (lui aussi alimenté en +5V / 0V). Ainsi les signaux négatifs donneront ne valeur comprise entre 1V et 0V quand les signaux positifs donneront une sortie comprise entre 1V et 5V. J’ai délibérément choisi Vref différent 2.5V pour obtenir une plus grande dynamique dans les températures positives (voir le chapitre 4 – Calculs).

NB:
La mesure de température est l’une des plus compliquées à réaliser: on mesure tout sauf ce qui nous intéresse (en réalité, on mesure la température de l’élément sensible, qui peut différer sensiblement de la température que l’on souhaite mesurer). En effet, pour mesurer une résistance électrique, il faut faire circuler un courant dedans! C’est là qu’intervient l’effet Joule: P = R.I². En mesurant la résistance de la sonde de température, on l’échauffe. Tout est question de compromis: il faut maintenir le courant assez faible pour limiter l’échauffement, mais il faut que la tension de point milieu du pont de Wheatstone soit suffisante pour polariser l’amplificateur d’instrumentation. Donc en alimentant le pont avec une tension faible, on s’assure de peut échauffer la sonde, mais l’amplificateur risque de ne pas fonctionner (j’ai eu des problèmes en alimentant le pont sous 50mV), par contre, en alimentant le pont avec une tension plus importante, on augmente le rapport signal sur bruit et on s’assure la polarisation de l’amplificateur, mais on chauffe la sonde… En alimentant le pont en 5V avec des résistances de 500 Ohms, j’ai un courant d’à peu près 5mA qui circule dans ma sonde, soit une puissance dissipée de 12.5mW à 0°C. À la mise sous tension, on observe une légère variation du signal de sortie due à l’auto échauffement de la sonde, mais l’effet reste négligeable pour des mesures courantes. Par contre si la sonde sert à mesurer la température d’un cryostat, il faut apporter un soin tout particulier au choix du courant traversant la sonde. Pour remplacer la Pt500 par une Pt100, il est souhaitable de monter une résistance de 100 Ohms en série avec le pont pour abaisser la tension d’alimentation du pont à 2.5V. Dans ces conditions, l’INA126 fonctionne et la sonde ne chauffe pas trop. Une astuce consistant à alimenter la sonde uniquement pendant l’acquisition de la tension de pont peut être utilisée pour limiter l’échauffement.

2 – L’alimentation

Pour ce projet, j’ai eu envie d’essayer quelque chose de nouveau: une alimentation mixte sur USB et sur batterie avec possibilité de recharge de la batterie par l’USB. Voici les problèmes auxquels je me suis heurté.

Tout d’abord, pour alimenter un montage fonctionnant en 5V à partir d’une source de tension aussi fluctuante que des piles ou une batterie, qui plus ai offrant une tension inférieure à 5V, il faut un régulateur de tension particulier. Une fois n’est pas coutume, Powertrend (racheté par TI) va nous simplifier la vie ! Pour l’histoire, Powertrend est une entreprise spécialisée dans la conception de régulateurs de tension à découpage. Il propose un régulateur BOOST, le PTN04050, qui peut fournir une tension ajustable entre 5V et 15V sous 12W à partir d’une alimentation comprise entre 2.65V et 5.5V. La seule contrainte est que la tension d’alimentation doit être au moins inférieure à la tension de sorties de 0.5V. C’est parfait me direz-vous, en mettant deux piles en série on atteint 3V, avec trois batteries en série, on monte à 3.6V, donc pas de quoi s’inquiéter ! En effet, si le montage était exclusivement alimenté par cette source d’énergie, il n’y aurait pas de problème. Mais je souhaite aussi alimenter mon thermomètre depuis l’USB, qui fournit lui du 5V… Il peut sembler idiot de réguler du 5V pour obtenir du 5V, mais dans le cas d’une alimentation double, c’est nécessaire.

Une petite pirouette électronique permet de s’en sortir honorablement! Pour choisir la source d’alimentation, je monte en série avec chaque source une diode AU SILICIUM (nous verrons pourquoi c’est important…).

Supposant une alimentation sur batterie, donc 3.6V en entrée. Quand la batterie alimente le montage, la tension à l’entrée du régulateur est 3.6V moins la tension de seuil de la diode (0.6V pour le silicium, cf diagramme d’énergie des semi-conducteurs => Eg = 0.6 eV pour le silicium) donc 3V (juste aux limites de fonctionnement du régulateur!). Quand l’USB est connecté, la tension à l’entrée du régulateur est donc 5V – 0.6V = 4.4V (là encore aux limites de fonctionnement du régulateur). Comme les 4.4V sont supérieurs aux 3.6V de la batterie, la diode en série avec la batterie se retrouve bloquée. C’est là que l’utilisation de diodes au silicium est obligatoire. En mettant une diode au germanium en série avec l’USB, on obtient en entrée du régulateur une tension de 5V-0.3V = 4.7V, trop proche du 5V de sortie, et le régulateur ne fonctionne pas correctement.

Enfin, une résistance de 10 Ohms entre l’alimentation USB et une diode montée en inverse en parallèle de l’interrupteur permettent la charge de la batterie sous un courant de (5V-3.6V-0.6V)/10 = 80mA (en réalité, les 80mA correspondent au courant de maintien, quand la batterie est complètement chargée).

3 – Le montage complet

La tension fournie par l’INA126 est directement appliquée à une entrée analogique du PIC18F4550, ainsi que la tension Vref. J’ai ajouté un LM35 pour pouvoir mesurer la température ambiante même sans la sonde Pt500. Le PIC travaille à une fréquence de 48MHz, à partir d’un quartz oscillant à 20MHz (cf: interface HID). Les températures sont affichées sur un écran LCD 2 lignes 16 caractères monté en mode 4bits. Le contraste et la luminosité du rétroéclairage (selon modèle) sont ajustés par deux potentiomètres. Un connecteur ICSP permet de programmer le PIC directement avec un pickit ou un autre programmateur afin de se passer d’un bootloader USB qui ralentit considérablement le démarrage du PIC.

Le schéma proposé peut être amélioré en connectant l’afficheur LCD sur un autre port pour récupérer les lignes 4 à 7 du port B (qui envoient des interruptions au microprocesseur) pour y connecter des boutons poussoirs.

4 – Calculs

Une fois le montage réalisé, il faut savoir comment, à partir des deux entrées analogiques du PIC, remonter à la température mesurée. Un peu de maths nous donnent rapidement la réponse:

Partons de la sonde. Pour une utilisation courante, je me suis fixé une dynamique de mesure allant de -40°C à +100 °C. Calculons les résistances de la sonde pour ces deux extrêmes (j’utilise un modèle à l’ordre un, négligeant les coefficients bêta, gamma et supérieurs):
R(-40) = 500\cdot (1 + 3.9\cdot 10^{-3}\cdot (-40)) = 422\Omega
R(100) = 500\cdot (1 + 3.9\cdot 10^{-3}\cdot 100) = 695\Omega

On obtient donc deux valeurs de Delta_R pour les deux extrêmes:

\Delta R_{min} = -78\Omega
\Delta R_{max} = 195\Omega

En introduisant cette sonde dans le pont suivant, on obtient:

V = E\cdot \frac{R2\cdot R3-R1\cdot R4}{(R1+R3)\cdot (R2+R4)}

On prend: R1 = R2 = R3 = R_0 ; R4 = R_0 + \Delta R en supposant de petites variations de Delta_R (inférieures à 10%), l’expression devient:

V = \frac{E}{4}\cdot \frac{\Delta R}{R}

Cette expression bien connue est très souvent prise pour argent comptant. Cependant, pour de grandes variations de résistances, comme pour notre application, ce modèle linéaire n’est plus valable:

Je vais donc utiliser la formule de base du pont. En la renversant, on obtient l’expression de R(Thêta) en fonction de R0, E et V la tension mesurée aux bornes du pont.

R(\theta ) = \frac{-R_0\cdot (2\cdot V-E)}{2\cdot V+E}

En introduisant l’expression de R(Thêta) en fonction de la température, on obtient l’expression suivante:

R_0\cdot (1+\alpha \cdot \theta) = \frac{-R_0\cdot (2\cdot V-E)}{2\cdot V+E} \Leftrightarrow \theta = \frac{-4\cdot V}{\alpha \cdot V+E}

Nous tenons donc l’expression de la température en fonction de la tension de déséquilibre du pont. Calculons maintenant les tensions correspondant à -40°C et 100°C afin de choisir le gain de l’amplificateur pour bénéficier de la pleine capacité des convertisseurs du PIC. Pour ce faire, je vais utiliser le modèle linéaire du pont.

V(100^oC) = \frac{5}{4} \cdot \frac{195}{500} = 488mV
V(-40^oC) = \frac{5}{4} \cdot \frac{-78}{500} = -195mV

Ce qui donne une excursion de 488+195 = 683 mV. Pour occuper l’excursion maximale des convertisseurs du PIC, il faut amener cette variation de 683mV au plus proche des 5V de pleine échelle. Donc un gain théorique de 5/0.683 = 7.32. J’ai choisi de me simplifier l’existence et de me contenter d’un gain de 5 (qui me permet de ne pas monter la résistance Rg de l’INA126). Avec ce gain de 5, une entrée de -40°C donne une tension de -975mV. Je choisis donc la tension Vref de l’INA126 à 1V. La température minimale mesurable est obtenue pour une tension de déséquilibre de -1/5 = -0.2V et devient donc:

\Delta R = \frac{4\cdot R\cdot V}{E} = \frac{4\cdot 500\cdot -0.2}{5} = -80\Omega
\theta = \frac{-(R_0-R(\theta )}{\alpha \cdot R_0} = \frac{-(500-420)}{3.9\cdot 10^{-3} \cdot 500} = -41.0^oC

Pour les valeurs positives, on refait le même calcul, avec cette fois-ci une tension de déséquilibre de 4/5 = 0.8V:
\Delta R = \frac{4\cdot R\cdot V}{E} = \frac{4\cdot 500\cdot 0.8}{5} = 200\Omega
\theta = \frac{-(R_0-R(\theta )}{\alpha \cdot R_0} = \frac{-(500-700)}{3.9\cdot 10^{-3} \cdot 500} = 102.5^oC

Calculons maintenant le quantum de température dû à l’échantillonnage à l’entrée du PIC. Les convertisseurs du PIC travaillent sur 10 bits, ce qui fait 1024 points:

q = \frac{102.5+41}{1024} = 0.14^oC

5 – Programmation

Comme on ne change pas une équipe qui gagne, j’ai utilisé MikroC pour programmer mon PIC. Le programme que je vous propose ci-dessous fait juste l’acquisition des tensions, le traitement et l’affichage. Je ne me suis pas encore penché sur l’interface USB et le logiciel PC de traitement de données.

// LCD module connections
sbit LCD_RS at LATB0_bit;
sbit LCD_EN at LATB1_bit;
sbit LCD_D4 at LATB2_bit;
sbit LCD_D5 at LATB3_bit;
sbit LCD_D6 at LATB4_bit;
sbit LCD_D7 at LATB5_bit;
 
sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB4_bit;
sbit LCD_D7_Direction at TRISB5_bit;
// End LCD module connections
 
#include "USBdsc.c"
#define TAILLE_BUFFER  64
#define TAILLE_MOYENNE 10
#define PE             5.
#define N              1024.
#define ALPHA          0.0039
#define E              5.
#define VOIE_OFFSET    2
#define VOIE_PT500     1
#define VOIE_LM35      0
#define GAIN_INA126    5
 
char ReadBuffer[TAILLE_BUFFER], WriteBuffer[TAILLE_BUFFER];
 
void Vider_Buffer(char * Buffer)
{
     char i;
     for (i=0;i<TAILLE_BUFFER;i++) Buffer[i]=0;
}
 
void interrupt()
{
    if (PIR2.USBIF == 1)
    {
      USB_Interrupt_Proc();
    }
}
 
void InitPic() {
     ADCON1=0b1011;
     CMCON = 7;
     TRISB = 0;
     
//------------- USB -------------
    TRISC.f4=1;  //D-
    TRISC.f5=1;  //D+
    HID_Enable(&ReadBuffer,&WriteBuffer);
}
 
int GetSample (int channel) {
    int i;
    int mean;
    
    mean = 0;
    
    for (i=0; i<TAILLE_MOYENNE; i++)
    {
      mean += ADC_Read(channel);
      Delay_ms(1);
    }
    mean /= TAILLE_MOYENNE;
    return mean;
}
 
void main() {
     float value;
     float offset;
     float temp_pt500 = 0;
     
     char ligne1[17];
     char ligne2[17];
     
     InitPic();
     Lcd_Init();
     Lcd_Cmd(_LCD_CLEAR);
     Lcd_Cmd(_LCD_CURSOR_OFF);
     while(1) {
              value = GetSample(VOIE_LM35) * PE / N;
              sprintf(ligne2, "LM35: %2.1f °C  ",value/0.01);
              Lcd_Out(2,1,ligne2);
              
              offset =  (GetSample(VOIE_OFFSET) * PE / N);
              value = ((GetSample(VOIE_PT500) * PE / N) - offset)/GAIN_INA126;
              temp_pt500 = (4. * value) / (ALPHA * (2.*value + E));
              sprintf(ligne1, "Pt500: %2.1f °C  ",temp_pt500);
              Lcd_Out(1,1,ligne1);
 
              Delay_ms(100);
     }
}

Libre à vous de modifier ce code pour l’adapter à votre application ! Bonne réalisation à vous et à la prochaine 😉 .

Mise à jour: Envoie des températures par USB

Afin d’exploiter au mieux ce thermomètre, j’ai enfin implanté un protocole de communication sur USB. Il s’inspire de la norme SCPI (prononcez skeepi…) utilisée pour les communications avec les instruments de mesure sur le bus GPIB. Le thermomètre est donc capable de répondre à certaines questions, par exemple *IDN? qui lui demande son nom.

Voici le code source du PIC:

// LCD module connections
sbit LCD_RS at LATB0_bit;
sbit LCD_EN at LATB1_bit;
sbit LCD_D4 at LATB2_bit;
sbit LCD_D5 at LATB3_bit;
sbit LCD_D6 at LATB4_bit;
sbit LCD_D7 at LATB5_bit;
 
sbit LCD_RS_Direction at TRISB0_bit;
sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB4_bit;
sbit LCD_D7_Direction at TRISB5_bit;
// End LCD module connections
 
#include "USBdsc.c"
#define TAILLE_BUFFER  64
#define TAILLE_MOYENNE 10
#define PE             5.
#define N              1024.
#define ALPHA          0.0039
#define E              5.
#define VOIE_OFFSET    2
#define VOIE_PT500     1
#define VOIE_LM35      0
#define GAIN_INA126    5
 
#define TMR0_PRECHARGE 28036
 
#define name           "Thermometre USB"
#define soft_rev       "1.1.0"
#define hard_rev       "1.0"
#define mcu            "PIC18F4550"
#define clk            "48MHz"
#define developper     "Amaury LAURENT"
#define release_date   "03/11/2012"
 
char ReadBuffer[TAILLE_BUFFER] absolute 0x500;
char WriteBuffer[TAILLE_BUFFER] absolute 0x540;
 
int GetSample (int channel);
char toogle = 0;
 
void Vider_Buffer(char * Buffer)
{
     char i;
     for (i=0;i<TAILLE_BUFFER;i++) Buffer[i]=0;
}
 
void interrupt()
{
    float value;
    float offset;
    float temp_pt500 = 0;
 
    char ligne1[17];
    char ligne2[17];
    
    if (PIR2.USBIF == 1)
    {
      INTCON.TMR0IE = 0;
      USB_Interrupt_Proc();
 
      if (HID_Read() != 0) {
        Vider_Buffer(WriteBuffer);
        if (strstr(ReadBuffer, "LM35?") != 0) {
           value = GetSample(VOIE_LM35) * PE / N;
           sprintf(WriteBuffer, "%2.1f",value/0.01);
        }
        else if (strstr(ReadBuffer, "MAX35?") != 0) {
           value = 4.99;
           sprintf(WriteBuffer, "%2.1f",value/0.01);
        }
        else if (strstr(ReadBuffer, "MIN35?") != 0) {
           value = 0.0;
           sprintf(WriteBuffer, "%2.1f",value/0.01);
        }
        else if (strstr(ReadBuffer, "PT500?") != 0) {
           offset =  (GetSample(VOIE_OFFSET) * PE / N);
           value = ((GetSample(VOIE_PT500) * PE / N) - offset)/GAIN_INA126;
           temp_pt500 = (4. * value) / (ALPHA * (2.*value + E));
           sprintf(WriteBuffer, "%2.1f",temp_pt500);
        }
        else if (strstr(ReadBuffer, "MAX500?") != 0) {
           offset =  (GetSample(VOIE_OFFSET) * PE / N);
           value = (4.99 - offset)/GAIN_INA126;
           temp_pt500 = (4. * value) / (ALPHA * (2.*value + E));
           sprintf(WriteBuffer, "%2.1f",temp_pt500);
        }
        else if (strstr(ReadBuffer, "MIN500?") != 0) {
           offset =  (GetSample(VOIE_OFFSET) * PE / N);
           value = (0.0 - offset)/GAIN_INA126;
           temp_pt500 = (4. * value) / (ALPHA * (2.*value + E));
           sprintf(WriteBuffer, "%2.1f",temp_pt500);
        }
        else if (strstr(ReadBuffer, "*IDN?") != 0) {
           strcpy(WriteBuffer, name);
        }
        else if (strstr(ReadBuffer, "*SREV?") != 0) {
           strcpy(WriteBuffer, soft_rev);
        }
        else if (strstr(ReadBuffer, "*HREV?") != 0) {
           strcpy(WriteBuffer, hard_rev);
        }
        else if (strstr(ReadBuffer, "*MCU?") != 0) {
           strcpy(WriteBuffer, mcu);
        }
        else if (strstr(ReadBuffer, "*CLK?") != 0) {
           strcpy(WriteBuffer, clk);
        }
        else if (strstr(ReadBuffer, "*AGE?") != 0) {
           strcpy(WriteBuffer, release_date);
        }
        else if (strstr(ReadBuffer, "*DEV?") != 0) {
           strcpy(WriteBuffer, developper);
        }
        else {
             strcpy(WriteBuffer, "Unknown command");
        }
        while(!HID_Write(&WriteBuffer, TAILLE_BUFFER));
        /*
        Lcd_Out(1,1,ReadBuffer);
        Lcd_Out(2,1,WriteBuffer);
        */
        Vider_Buffer(ReadBuffer);
      }
 
      INTCON.TMR0IE = 1;
    }
 
    if (INTCON.TMR0IF == 1) {
       PIE2.USBIE = 0;
       TMR0L = TMR0_PRECHARGE % 256;
       TMR0H = TMR0_PRECHARGE / 256;
       
       if (toogle == 0) {
          Lcd_Init();
          Lcd_Cmd(_LCD_CLEAR);
          Lcd_Cmd(_LCD_CURSOR_OFF);
          toogle = 1;
       }
 
       value = GetSample(VOIE_LM35) * PE / N;
       sprintf(ligne2, "LM35: %2.1f °C  ",value/0.01);
       Lcd_Out(2,1,ligne2);
 
       offset =  (GetSample(VOIE_OFFSET) * PE / N);
       value = ((GetSample(VOIE_PT500) * PE / N) - offset)/GAIN_INA126;
       temp_pt500 = (4. * value) / (ALPHA * (2.*value + E));
       sprintf(ligne1, "Pt500: %2.1f °C  ",temp_pt500);
       Lcd_Out(1,1,ligne1);
 
       INTCON.TMR0IF = 0;
       PIE2.USBIE = 1;
    }
}
 
void InitPic() {
     ADCON1=0b1011;
     CMCON = 7;
     TRISB = 0;
     TRISD.f0 = 0;
     TRISD.f1 = 0;
     
     LATD.f0 = 1;
     LATD.f1 = 1;
     
     //------ Display Timer IT -------
    INTCON.GIE = 1;
    INTCON.PEIE = 1;
    INTCON.TMR0IE = 1;
    PIE2.TMR1IE = 1;
 
    TMR0L = TMR0_PRECHARGE % 256;
    TMR0H = TMR0_PRECHARGE / 256;
    T0CON = 0b110000100; // PS = 32
     
    //------------- USB -------------
    TRISC.f4=1;  //D-
    TRISC.f5=1;  //D+
    HID_Enable(&ReadBuffer,&WriteBuffer);
}
 
int GetSample (int channel) {
    int i;
    int mean;
    
    mean = 0;
    
    for (i=0; i<TAILLE_MOYENNE; i++)
    {
      mean += ADC_Read(channel);
    }
    mean /= TAILLE_MOYENNE;
    return mean;
}
 
void main() {
     
     InitPic();
 
     while(1) ;
}

Pour communiquer avec le thermomètre, vous pouvez utiliser LabVIEW et les drivers VISA, ou bien faire appel à la dll hid (sous Windows) pour accéder au périphérique avec d’autres langages. Voici un exemple de logiciel écrit en C# (prononcer C sharp).

Télécharger le projet MikroC

Cet article Thermomètre USB à sonde de platine est apparu en premier sur Electronique et Informatique.

Afin de mettre en application les connaissances vues en cours de capteur, nous avons mené un microprojet dont le but était de réaliser un capteur avec les moyens du bord. Le groupe était constitué de cinq étudiants. Après tirage au sort, nous sommes tombés sur la réalisation d’un débitmètre massique. Voici le récit palpitant de cette épopée instrumentale!

Composition du Groupe de Projet

• PERRIN Jimmy
• HOYAU Jean-Philippe
• LAURENT Amaury
• MATUSZEK Guillaume
• MERCHAT Grégory

Sujet imposé

Le but du projet est de concevoir et de réaliser un « débitmètre massique » à effet thermique, permettant de mesurer, soit le débit, soit la vitesse d’un fluide (qui dans notre cas sera de l’air), selon le principe de la mesure de températures dans une veine de fluide, de part et d’autre d’un système de chauffage.
Il s’agira de réaliser d’une part, la partie « mécanique » comportant la prise de températures (thermocouples) et le chauffage du tube et le circuit de mesure des tensions délivrées par les sondes de température, et la partie « acquisition » d’autre part, via une carte d’acquisition et LabVIEW.

Matériel à notre disposition

• Carte d’acquisition NI DAQ PCI 6024
• 2 conditionneurs pour Thermocouples type K: THAK 200
• 2 thermocouples types K gainés

Principe de base

1. On déroute une veine de fluide pour la faire passer dans notre capteur.
2. L’organe de chauffage communique sa puissance au fluide (et uniquement au fluide, dans l’idéal).
3. Deux sondes de températures sont placées en amont et en aval de l’organe de chauffage pour mesurer la différence de température.

Calculs préliminaires

Le principe de base du débitmètre massique à effet thermique est de communiquer de la chaleur à un fluide. En mesurant la différence de température entre avant et après l’élément chauffant, on arrive à remonter au débit du fluide.

Dans un tube de fluide, le débit massique est donné par:

Où Qm est le débit massique (kg/m^3), m est la masse (kg) et t est le temps (s).

En outre, l’échauffement d’un corps est régi par la loi suivante:

Où Q est la chaleur apportée au corps (J), m est la masse (kg), Cp est la capacité calorifique massique du fluide (J/(kg.K)) et dT est le gradient de température.

En différenciant cette expression, on obtient:

Où P est la puissance apportée au fluide et Qm sont débit massique. En mesurant dT, connaissant Cp et P, on arrive à calculer Qm.

Réalisation

La première chose à faire est d’obtenir une veine de fluide que l’on puisse chauffer et sur laquelle on puisse effectuer nos mesures. La manière la plus simple est de la confiner dans un tuyau. De quel diamètre me direz-vous? En première approximation, je vous répondrai: « Celui que vous avez… ». En deuxième approximation, il faut que le diamètre du tube soit suffisamment important pour que l’écoulement soit laminaire. Attention, plus le tuyau est de grand diamètre, plus la puissance de chauffage doit être importante pour un même dT.

Nous avons effectué plusieurs tests avec:

• Un tube IRO de 16mm
• Un tube PVC de 32mm x 2mm
• un tube acier de 36mm x 2mm

Nous avons retenu le tuyau d’acier pour sa bonne conduction thermique et sa bonne tenue en température (le tube iro et le PVC ont fondu assez vite…)

Pour l’organe de chauffage, du fil de cuivre bobiné autour du tuyau fait parfaitement l’affaire. Nous avons essayé un grand nombre de spires de fil fin (0.16mm de diamètre) et moins de spires de fil plus gros. Le plus intéressant pour nous fut de bobiner du fil de moyenne section de façon à obtenir une résistance de 1 Ohm. Ainsi, le calcul de la puissance fournie au fluide est simplifié. Pour être sûr que la puissance de chauffage parte entièrement dans le fluide, il faut calorifuger le capteur.

Il ne reste plus qu’à choisir une alimentation suffisante pour notre capteur et à implanter les deux thermocouples. L’alimentation choisie est, sans surprise, une vieille alimentation de PC capable de nous fournir 25W sous 5V et 144W sous 12V.

Pour accélérer le démarrage du capteur, nous faisons chauffer la résistance sous 144W jusqu’à 60°C, puis nous descendons à 25W. En restant tous le temps à 144W, le fils peut allègrement dépasser les 130 °C, température à laquelle l’isolant du fil commence à brûler (eh oui, on a essayé…).

Pour réaliser des mesures répétables, nous avons fabriqué un banc de test équipé d’un ventilateur et d’un guide pour canaliser le flux d’air vers le capteur.

Le compte rendu de projet au format PDF: Compte_Rendu_Microprojet.pdf
Le programme LabVIEW: programmes.rar

Cet article Débitmètre massique est apparu en premier sur Electronique et Informatique.