Utilisation du kit d’évaluation Atmel ATAVRSBRP1

Nous avons reçu il y a quelques temps une platine d’évaluation d’un capteur de pression barométrique pour le système Atmel Sensors Xplained. Cette platine nous a été gracieusement donnée par l’un de nos fournisseur : Farnell, dans le but de réaliser une évaluation.

Ne disposant pas du système hôte Atmel Sensors Xplained, nous avons légèrement détourné la destination ce kit d’évaluation, afin de l’utiliser directement avec une carte Arduino Uno.

Premier contact

La platine étant conçue par Atmel, c’est naturellement sur le site du fabricant que nous récupérons la documentation

Dans la documentation nous découvrons que :
– la platine d’évaluation du capteur est interfacée en i2c (adresse 0x77 pour les 7 premiers bits).
– son brochage (connecteur J2) est :
1 SDA (données i2c)
2 SCL (horloge i2c)
3 CLR (? signal non connu)
4 EOC (? signal non connu)
9 GND (0V)
10 PWR

Cependant, il nous manque la valeur de la tension d’alimentation PWR.

La documentation nous indique que le capteur de pression BMP085 est de marque Bosh. Une rapide recherche sur internet nous permet de retrouver sa documentation.

Ainsi, on découvre qu’il peut être alimenté entre 1,8 et 3,6V. On pourra donc utiliser l’alimentation 3,3V de l’Arduino. Enfin, on intercalera un convertisseur de niveau 5V <-> 3.3 V entre l’Arduino et le capteur pour la connexion i2c.

Dans cette documentation on trouve aussi le rôle des signaux CLR et EOC :

– CLR est une entrée permettant le reset du capteur (actif au niveau bas, durée 1 µs), mais comme un reset est aussi effectué à la mise sous-tension, il n’est pas nécessaire d’utiliser cette entrée pour l’instant. Nous la laisserons non connectée, le capteur de pression incluant une résistance de pull-up.
– EOC est une sortie indiquant la fin d’une conversion. Là aussi, nous pouvons attendre suffisamment longtemps par software afin d’éviter d’utiliser ce signal sur une entrée d’interruption de notre Arduino.

Le schéma

Pour la réalisation d’un circuit qui nous permette de tester le capteur barométrique, nous avons besoin de :

– 1 carte Arduino Uno
– 1 convertisseur 5V-3.3V
– des fils
– éventuellement une breadboard pour y insérer le convertisseur et réaliser des connexions

Les branchements à effectuer sont au final assez simples :
– le pin 9 du capteur, qui correspond à la masse, est connecté sur la masse de l’Arduino ;
– le pin 10 du capteur, qui correspond à l’alimentation, sur le pin 3.3V de l’Arduino ;
– le pin 1 du capteur, qui correspond à la ligne SDA (data) de la connexion i2c, sur le pin A4 de l’Arduino, via le convertisseur de niveau logique ;
– le pin 2 du capteur, qui correspond à la ligne SCL (clock) de la connexion i2c, sur le pin A5 de l’Arduino, via le convertisseur de niveau logique ;

Fred a réalisé le schéma sur Fritzing :

L’ensemble est téléchargeable ci-dessous :

Le câblage final donne :

Comment réaliser une lecture de pression ?

Après un parcours en détail de la datasheet du capteur BMP085, la lecture d’une pression atmosphérique est loin d’être une simple opération de lecture i2c.

En effet, la température et la pression qui seront lues par le capteur ne sont pas calibrées, aussi il faudra effectuer un certain nombre d’opérations arithmétiques avant d’arriver à notre but.

1) Initialisation
– il faut attendre au moins 10ms après le reset du capteur.
– lecture des coefficients. Chaque capteur BMP085 contient une liste de coefficient calibrés d’usine accessibles via plusieurs adresses i2c. Bien que ces coefficients soient définis comme short ou unsigned short par Bosch, nous avons décidé après quelques tentatives infructueuses de les convertir en long afin d’éviter les problèmes d’arithmétique et de conversion entre des short, des unsigned short et des long.
Les coefficients sont notés ac1, ac2, ac3, ac4, ac5, ac6, b1, b2, mb, mc, md. Le premier paramètre est accessible à l’adresse 0xAA. Les autres suivent jusqu’à l’adresse 0xBE. Ils ont tous une taille de 2 octets. Attention certains coefficient sont signés et d’autres pas, donc ne pas oublier de ’caster’ correctement ces coefficients lors de leur affectation dans les variables prévues à cet effet.

Pour lire un octet contenu dans le capteur, il faut procéder de la sorte :
– tout d’abord démarrer une séquence d’écriture i2c ;
– écrire sur le canal i2c l’adresse de l’octet que l’on souhaite lire (par exemple écrire 0xAA pour accéder au coefficient ac1) ;
– terminer la séquence d’écriture ;
– initier une séquence de lecture i2c, en indiquant le nombre d’octets que l’on souhaite lire ;
– à chaque lecture l’adresse de l’octet lu est incrémentée de 1. Par exemple, pour accéder au coefficient ac1, on procède à la lecture de deux octets, puisque ce coefficient en codé sur 16 bits (cf. documentation du BMP085) ;

2) Démarrer une lecture de température non calibrée et calculer la température exacte.
Cette étape est nécessaire. Elle permet d’obtenir une température ambiante au dixième de degré celsius près. En outre, elle permet de calculer un certain nombre de coefficients temporaires utiles pour le calcul final de la pression atmosphérique (coefficient b5 notamment).
Le démarrage de la température se fait en écrivant la valeur 0x2E sur le registre de contrôle à l’adresse 0xF4. Cette opération indique au capteur que c’est le relevé de température qu’il doit mettre dans le registre à l’adresse 0xF6 que nous lirons ensuite.

Puis il nous faut attendre 5 ms, que le capteur effectue le relevé de température et le mette dans le registre 0xF6.

La lecture de ce relevé, qui est une valeur non calibrée, se fait à l’adresse 0xF6 sur 2 octets.
S’en suivent quelques opérations arithmétiques permettant d’obtenir la valeur exacte de la température.
Nous n’avons fait que suivre l’algorithme donné par Bosch. Nous sommes incapables d’expliquer la suite de calculs !!! Au bout du compte nous obtenons une température avec le bon ordre de grandeur (24.6 °C), mais qui nous a paru un peu élevée par rapport à la température ressentie dans la pièce (plutôt autour de 20°C).

3) Démarrer une lecture de pression non compensée et calculer la pression exacte.
L’obtention de la pression atmosphérique peut être effectuée selon différents échantillon ages, plus ou moins précis.
Le type d’échantillonnage est contrôlé par le paramètre oss, qui peut varier de 0 (échantillonnage le moins précis) à 3 (échantillonnage le plus précis). Chaque valeur d’échantillonnage correspond à une valeur spécifique à écrire dans le registre de contrôle (0xF4) du capteur. La lecture de pression est d’autant plus longue selon le type d’échantillonnage :
– oss 0 : 0x34, durée de 5 ms
– oss 1 : 0x74, durée de 8 ms
– oss 2 : 0xB4, durée de 14 ms
– oss 3 : 0xF4, durée de 26 ms

Lorsque la durée de lecture est atteinte, on peut lire le registre de valeur en 0xF6 sur 3 octets. De même que pour la température, une suite de calculs arithmétiques permet de retrouver la valeur réelle de la pression atmosphérique. Nous avons obtenu un résultat de 99800 Pa, soit presque 1 bar, qui correspond à la pression atmosphérique normale.

La bibliothèque

A la suite de ces premiers essais, Vincent a mis au point une bibliothèque qui permet d’utiliser simplement le capteur Bosch. Elle permet de créer un objet de type BMP085, qui comporte les méthodes suivantes :

– init() : Cette méthode doit être lancées avant toute mesure de température ou pression. Elle doit être lancée après avoir initialisé le bus I2C. Elle permet de lire et de stocker dans l’objet créé les coefficients ac1, ac2, etc...

– getTemperature() Cette méthode renvoie la mesure de la température, en dixième de degré celsius.

– getPressure() Cette méthode renvoie la mesure de la pression atmosphérique, en Pascal, avec la méthode d’échantillonnage la moins précise (oss = 0) ;

– getPressure(int oss) Cette méthode renvoie la mesure de la pression atmosphérique, en Pascal, avec la méthode d’échantillonnage indiquée en paramètre ;

A noter que cette bibliothèque s’appuie sur Wire pour l’utilisation de l’i2c. Wire est donc incluse en en-tête.

Le code ci-dessous utilise la bibliothèque permet de tester le capteur selon le schéma fournit :

#include <Wire.h>
#include "BMP085.h"

BMP085 bmp085;

void setup()
{
  Wire.begin();        // join i2c bus (address optional for master)
  bmp085.init();
  Serial.begin(9600);  // start serial for output
}

void loop()
{
  unsigned long t = bmp085.getTemperature();
  Serial.print("Temperature : ");
  Serial.print(t/10);
  Serial.print('.');
  Serial.print(t%10);
  Serial.print(" C, ");
 
  unsigned long p = bmp085.getPressure()/100;
  Serial.print("Pression : ");
  Serial.print(p/100);
  Serial.print('.');
  Serial.print(p%100);
  Serial.print(" hPa.\n");
 
  delay(1000);
}

Le code et la bibliothèque sont disponibles comme projet Arduino ci-dessous :

Conclusion

La mise en œuvre de ce capteur nous a permis d’apprendre et d’expérimenter différents aspects de l’Arduino :
– compréhension du fonctionnement haut-niveau du bus i2c, fonctionnement en maitre avec lecture de données sur un périphérique ;
– création d’une bibliothèque proposant une interface simple (4 méthodes) permettant de simplifier énormément l’utilisation du capteur dans un sketch Arduino ;
– prise en main de Fritzing pour réaliser le schéma de câblage ;

Bonne expérimentation à tous.