I2C : Capteur de pression et niveau d'eau

I2C : Capteur de pression et niveau d'eau

Le tout nouveau Yocto-I2C permet d'interfacer des composants I2C, mais il permet aussi de les tester sans avoir à coder toute une interface, et ça c'est plutôt appréciable. Cette semaine on a décidé d'en profiter pour jouer avec les capteurs de pression DLHR d'Amphénol.

Ça fait un moment que le "département R&D" louche sur ces capteurs en se demandant s'il y a un intérêt à faire un module Yoctopuce basé sur cette gamme de capteurs. Le problème, c'est qu'il existe une bonne douzaine de variantes en fonction de l'intervalle de pression que l'on désire mesurer. Faire autant de modèles qu'il y a de variantes aurait été littéralement ingérable, d'où notre hésitation. L'arrivée du Yocto-I2C nous a donc donné l'occasion de tester ce capteur et de vous montrer comment l'interfacer.

La série des capteurs DLHR

Les capteurs DLHR d'Amphénol sont des capteurs différentiels: ils mesurent la différence de pression entre leurs deux entrées. Il se présentent sous différentes formes et offrent différents intervalles de pression de 125 Pascal à 15 kPa. Tous offrent au moins une interface I2C. On a jeté notre dévolu sur un DLHR-L01D et un DLHR-L30G. On les a soudé sur un petit breadboard pour pouvoir les munir de fils plus facilement.

Le capteur de pression différenciel DLHR-L01D, soudé sur un breadboard
Le capteur de pression différenciel DLHR-L01D, soudé sur un breadboard


Connexion

La première chose à faire consiste à télécharger le datasheet du capteur et le lire. on y apprend que que le capteur fonctionne en 3.3V et que les pins 1,2,3 et 4 correspondent respectivement à Gnd, Vsupply, SDA et SDL, il n'y a même pas besoin de condensateurs de découplage, ce qui rend la connexion au Yocto-I2C triviale.

Connection au Yocto-I2C
Connection au Yocto-I2C


Configuration

Dans le VirtualHub, la configuration du Yocto-I2C pour ce capteur consiste à mettre la tension d'alimentation à 3.3V et la vitesse du port à 100kbps. Officiellement le capteur supporte jusqu'à 400kbps, mais on n'a pas réussi à le faire fonctionner à cette vitesse.

Configuration  dans le VirtualHub
Configuration dans le VirtualHub


Test de la communication

Une fois que tout est branché et configuré, on peut tester la communication I2C. Pour cela, le plus simple consiste à vérifier que le capteur répond à sa propre adresse I2C. Le datasheet nous indique que cette adresse est 41 en décimal soit 0x29 en hexadécimal . En utilisant l'interface du virtualHub, on va simplement simplement envoyer au capteur:

  • Une condition Start {S}
  • L'adresse du capteur (sur 7 bits) suivi d'un bit de lecture à 0, soit 0x29 * 2 + 0 = 0x52
  • Une condition Stop {P}

Si tout se passe bien le capteur va répondre par un "acknowledge" ({A}) et l'interface du VirtualHub va afficher la réponse sous la forme adresse, deux points, réponse du capteur, soit 29:{A}.

Test dans le VirtualHub
Test dans le VirtualHub

.
Si la réponse se termine par un point d'exclamation c'est qu'il y a un problème, les causes peuvent être multiples: fils mal branchés, mauvaise adresse, mauvaise vitesse etc... Corrigez le problème et faites un power cycle du module avant de réessayer, histoire d'être sûr que le capteur est dans état sain.

Mesures

Une étude attentive du datasheet nous révèle que le protocole I2C utilisé dans le DLHR est plus simple que celui de la plupart des senseurs I2C: il n'y a pas de concept de registres. Pour déclencher une mesure il suffit d'écrire la valeur 0xAA sur le port. Pour savoir si la mesure est finie, il suffit de lire directement un byte, et si le bit 5 de ce byte est à zéro, on peut lire encore 6 bytes de plus qui représentent la pression et la température codés sur 24 bits. Donc si on résume:

  1. On écrit le byte 0xAA à l'adresse 0x29*2=0x52 sur le port I2C : {S}52AA{P}
  2. On lit un byte : {S}53xx{N}{P}, notez le 52 qui se transforme en 53 à cause du bit de lecture.
  3. Le capteur répond par son byte de status. Si le bit 5 de la réponse est à zéro, on recommence mais cette fois on lit 7 bytes en tout: status (1 byte) + pression (3 bytes)+ temperature (3 bytes): {S}53xx{A}xx{A}xx{A}xx{A}xx{A}xx{A}xx{N}{P}. Remarquez que tous les bytes lus sont "ACKés" sauf le dernier qui est "NACKé".

interrogation du capteur
interrogation du capteur

.
Dans notre exemple ci dessus, le byte de status vaut 0x40, la pression vaut 0x802C80 et la température vaut 0x800C86 il ne reste plus qu'à utiliser les fonctions de transfert du DLHR pour les convertir en unité utilisables, c'est à dire hauteur d'eau en pouce et °C.

Fonctions de transfert tirées du datasheet du DLHR
Fonctions de transfert tirées du datasheet du DLHR

.
Notez que ces fonctions utilisent des constantes qui dépendent du modèle de capteur.

Automatisation

A ce niveau on pourrait coder le protocole I2C dans le langage de notre choix, mais il y a plus efficace: on peut utiliser le système de jobs du Yocto-I2C. Ainsi le module va interroger automatiquement le capteur et présenter le résultat dans ses generic sensors. Par exemple on peut créer un job, consisté de 3 tâches, qui est en fait une machine à 3 états pilotée par la variable $state:

  • Tâche d'initialisation (périodique, une fois) qui initialise quelques variables, attention les valeurs de $OSDig et $FSS dépendent de la variante du capteur, ici on travaille avec un DLHR-L30G:

    • assert !isset($state)
    • compute $OSdig=0.1*2**24
    • compute $FSS=30
    • compute $state=0

  • Tâche de mesure (périodique, 10hz) qui lance la mesure

    • assert $state==0
    • writeLine {S}52AA{P}
    • expect 29:{A}{A}
    • compute $state=1

  • Tâche récupération des données (périodique, 10hz) qui teste le byte de status, lit la réponse, convertit les données en °C et inH2O et place le résultat dans les generic sensors 1 et 2.

    • assert $state==1
    • writeLine {S}53xx{N}{P}
    • expect 29:{A}($s:BYTE).*
    • assert ($s & 0x20) == 0
    • writeLine {S}53xx{A}xx{A}xx{A}xx{A}xx{A}xx{A}xx{N}{P}
    • expect 29:{A}($S:BYTE)($P2:BYTE)($P1:BYTE)($P0:BYTE)($T2:BYTE)($T1:BYTE)($T0:BYTE)
    • compute $1 =-40 + ($T0 + ($T1<<8) + ($T2<<16))*125 / (2**24)
    • compute $2=$FSS*1.25*($P0 + ($P1<<8) + ($P2<<16) - $OSdig ) /(2**24)
    • compute $state=0

Pour vous éviter d'avoir à entrer tout ce code, voici le fichier job correspondant, si vous voulez essayer, il vous suffira de le copier sur le système de fichiesr de votre Yocto-I2C. Les mesures de pressions sont données en pouces d'eau. On a utilisé le système de conversion des generic sensors pour obtenir des mm d'eau.

convertion pouces vers mm
convertion pouces vers mm


Et ça marche?

Pour vérifier si ça marche on a installé un tube en plexi vertical dans un aquarium et on a relié le haut de tube à l'entrée du capteur DLHR. L'eau va essayer de pénétrer dans le tube en créant ainsi une légère surpression.

Principe de l'expérience
Principe de l'expérience


La difficulté a été de trouver un tuyau suffisement fin pour l'adapter au tubulures d'entrée du capteur. Puis on a commencé a remplir l'aquarium.

On a fait des test avec un aquarium
On a fait des test avec un aquarium


Le fait d'avoir utilisé les systèmes de job et les generic sensors du Yocto-I2C nous permet d'utiliser Yocto-Visualization pour surveiller l'expérience. Il faut bien avouer qu'on a été bluffé par la sensibilité des capteurs: les deux capteurs qu'on a essayé peuvent détecter sans problème des changements de moins d'1 mm d'eau. Lorsqu'on verse de l'eau dans l'aquarium on distingue parfaitement les changements de niveau causés par les vaguelettes qui s'amortissent peu à peu.

on a versé de l'eau dans l'aquarium
on a versé de l'eau dans l'aquarium


En revanche sur le long terme on a remarqué quelques phénomènes intéressants:

  • Malgré le fait que le DLHR soit compensé en température, les changements brusques de température causent des variations significatives
  • On a noté une dérive à la baisse dont on n'est pas trop sûrs qu'elle soit du au capteur, à l'évaporation, ou à une fuite d'air dans notre système
  • On aussi remarqué une grosse sensibilité aux vibrations, ce qui suivant l'application peut être un avantage ou un inconvénient.

mesures sur 4 jours
mesures sur 4 jours



Conclusion

On ne fera probablement pas de capteur Yoctopuce basé sur ces capteurs DLHR parce qu'il y a trop de modèles différents. En revanche vous pouvez facilement les interfacer avec un Yocto-I2C et vous retrouver avec quelque chose de sensiblement équivalent à un capteur Yoctopuce.

Commenter aucun commentaire Retour au blog












Yoctopuce, get your stuff connected.