BH1750. Capteur de lumière ambiante avec bus I2C.
Le BH1750 est un capteur d'éclairage ambiant doté d'une résolution et d'une sensibilité raisonnablement élevées. Il se comporte face à la lumière visible d'une manière comparable à celui de l'œil humain et n'est pas affecté par le rayonnement infrarouge et ne dépend pas non plus de la température de couleur du type d'éclairage, c'est-à-dire qu'il fonctionne bien avec la lumière naturelle et avec différents types d'éclairage artificiel. Il communique numériquement avec le microcontrôleur, avec le Bus I2C, il résiste donc aux interférences s'il est placé à une certaine distance du circuit qui le lit. Son temps de réponse est assez faible, inférieur à 200 ms dans les circonstances les plus défavorables.
Du point de vue électronique, sa mise en œuvre est très simple. Il suffit de brancher l'alimentation (entre 2,4 V et 3,6 V) et le Bus I2C. En option, l'adresse du bus peut être modifiée pour connecter deux appareils (avec ADDR à un niveau bas, c'est 0B0100011 ou 0x23 et avec ADDR à un niveau élevé, c'est 0B1011100 ou 0x5C) et la ligne VDI peut être utilisée pour la fonction de réinitialisation avec le microcontrôleur.
Pour connecter le BH1750 à Arduino, en plus d'être alimenté par la sortie 3,3 V, le plus correct est d'utiliser un convertisseur de niveau en plus du résistances de rappel pour lui Bus I2C. Bien que le composant prenne en charge une connexion directe au bus Bus I2C Il n'est pas conseillé de dimensionner un circuit sans considérer la conversion du niveau.
En raison de sa popularité, qui est due à son prix très bon marché par rapport à sa précision, il existe plusieurs modules, comme le célèbre GY-30, que l'on peut voir sur la photo du début. Pour les connecter plus confortablement lors du prototypage avec un microcontrôleur, ils incluent généralement des convertisseurs de niveau pour le Bus I2C et des régulateurs de tension pour les alimenter avec une tension plus élevée (jusqu'à 5 V) au lieu de la sortie 3,3 V de Arduino.
Le BH1750 dispose de deux modes de lecture, continue et individuelle, qui correspondent à deux états, actif et faible consommation ou veille. Alors que si le mode de lecture continue est utilisé, le BH1750 reste actif après l'échantillonnage, après avoir effectué une mesure individuelle, il entre automatiquement en mode veille et faible consommation. La première lecture en mode continu prend au maximum 180 ms et les suivantes entre 16 ms et 120 ms selon la résolution.
Le capteur est capable de mesurer à des intervalles (résolution) de 4 lux, 1 lux et 0,5 lux. Le BH1750 recommande dans sa fiche technique d'utiliser la résolution de 1 lux, qui permet de distinguer un éclairement inférieur à 10 lux (ce qui correspond à la lumière crépusculaire) et qui est plus insensible au bruit pouvant affecter la mesure.
Les résolutions de 1 lux et 4 lux utilisent les 16 bits de données pour représenter la partie entière afin qu'une mesure maximale de 65535 0,5 lux puisse être atteinte (journée ensoleillée sans lumière directe). Le mode 0,5 lux utilise le bit le moins significatif pour la partie décimale (mesure de 0,5 lux à 15 lux) donc avec les 32767 bits restants il est possible de représenter une valeur maximale de XNUMX lux (extérieur sans lumière directe)
Normalement, la fenêtre optique selon laquelle la lumière ambiante est mesurée correspond à l'ensemble du spectre visible et l'objectif est d'y obtenir une répartition de sensibilité comparable à celle de l'homme. Si la fenêtre optique est réduite (la lumière est mesurée dans une plage de longueurs d'onde inférieure) la sensibilité du BH1750 peut être augmentée (jusqu'à 0,11 lux) avec un mode d'annulation du réglage de l'influence de la fenêtre optique en augmentant la lecture du temps en proportion. Puisque dans ce mode spécial (surdimensionné) des lectures séparées sont effectuées, le contexte doit le permettre sans altérer particulièrement les conditions de mesure (par exemple, le capteur doit rester très stable, il ne doit pas se déplacer dans une zone avec des conditions d'éclairage différentes)
Codes de fonctionnement du BH1750
Ville
5>
-
0B00000000(0x00) Faible consommation ou mode veille. -
0B00000001(0x01) Allumé. -
0B00000111(0x07) Réinitialiser. Efface les journaux de données du BH1750.
Résolution
5>
-
0B00010011(0x13) Mesure continue à une résolution de 4 lux (entre 16 ms et temps de lecture) -
0B00010000(0x10) Mesure continue à une résolution de 1 lux (temps de lecture 120 ms) -
0B00010001(0x11) Mesure continue à une résolution de 0,5 lux (temps de lecture 120 ms) -
0B00100011(0x23) Une mesure à une résolution de 4 lux (temps de lecture 16 ms) -
0B00100000(0x20) Une mesure à une résolution de 1 lux (temps de lecture 120 ms) -
0B00100001(0x21) Une mesure à une résolution de 0,5 lux (temps de lecture 120 ms)
Ajustement pour changement de fenêtre optique
5>
-
0B011MT[0,1,2,3,4] Bit bas du registre MTREG (Measurement Time REGister). -
0B01000MT[5,6,7] MTREG enregistre le bit haut.
Lisez le BH1750 d'Arduino
Pour mesurer l'éclairage ambiant avec le BH1750 de Arduino la bibliothèque est utilisée fil qui gère les communications avec le Bus I2C. Le processus est habituel dans ce type de communications, elles sont d'abord activées (une fois dans le programme) avec Wire.begin(), la communication avec le BH1750 commence par Wire.beginTransmission() et votre adresse I2C (0x5C ou 0x23 selon que l'ADDR est respectivement haut ou bas), il se configure en envoyant le code correspondant avec Wire.write() et le bus est libéré avec Wire.endTransmission()
|
15
|
Wire.begin();
|
|
17
18
19
|
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.write(MEDIDA_CONTINUA_UN_LUX_BH1750);
Wire.endTransmission();
|
Si l'un des modes de lecture continue est utilisé, Wire.beginTransmission() est utilisé pour obtenir les données avec l'adresse I2C correspondant à l'accès au BH1750, deux octets sont demandés (la résolution est de 16 bits) avec Wire.requestFrom() qui sont lus, en utilisant Wire.read(), et sont chargés dans un entier non signé, en faisant tourner le premier octet de 8 bits. Le bus est ensuite libéré avec Wire.endTransmission(). Le résultat final est obtenu en divisant la valeur renvoyée par le facteur de précision (1,2 si la fenêtre optique n'est pas modifiée)
|
28
29
|
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.requestFrom(DIRECCION_BH1750_0,2);
|
|
37
38
|
lectura_BH1750=Wire.read()<<8; // Leer el primer byte y rotarlo 8 bits
lectura_BH1750|=Wire.read(); // Leer el segundo byte y «juntarlo» con el anterior on OR
|
|
40
|
iluminacion=long(100.0*(float)lectura_BH1750/DIVISOR_PRECISION)/100; // Resultado corregido y sin decimales
|
Si le mode lectures individuelles est utilisé, le BH1750 passe en mode veille. Pour revenir en mode actif, une configuration (le même mode de lecture ou un nouveau) ou le code de mise sous tension (0x01) peut être envoyé. Le code d'arrêt (1750x0) peut être utilisé pour forcer le BH00 en mode veille.
Il est important de respecter le temps de lecture du capteur, qui dépend de la résolution. Si l'attente n'est pas critique, elle peut être unifiée en une valeur pour tous les cas qui peut être légèrement supérieure au maximum attendu pour garantir la fin de la lecture.
Pour rendre l'écriture du code du BH1750 plus confortable dans Arduino, les codes d'opération les plus pertinents se trouvent dans le document d'en-tête suivant.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#define REPOSAR_BH1750 0x00 // Modo de reposo o bajo consumo
#define ENCENDER_BH1750 0x01
#define RESETEAR_BH1750 0x07
#define MEDIDA_CONTINUA_CUATRO_LUX_BH1750 0x13
#define MEDIDA_CONTINUA_UN_LUX_BH1750 0x10
#define MEDIDA_CONTINUA_MEDIO_LUX_BH1750 0x11
#define MEDIDA_SIMPLE_CUATRO_LUX_BH1750 0x23
#define MEDIDA_SIMPLE_UN_LUX_BH1750 0x20
#define MEDIDA_SIMPLE_MEDIO_LUX_BH1750 0x21
#define ESPERA_BH1750_0 250 // 250 milisegundos de espera de lectura del BH1750 (mayor que la máxima)
#define TIMEOUT_I2C 10 // 10 milisegundos de espera antes de renunciar a leer el bus I2C
#define DIVISOR_PRECISION 1.2 // valor por el que dividir la lectura para calcular la luminosidad 1.2 si no hay cambios en la ventana óptica
#define DIRECCION_BH1750_0 0x23
#define DIRECCION_BH1750_1 0x5C
|
L'exemple de code suivant montre le mode de lecture le plus courant dans le capteur de lumière I2C BH1750. La résolution est de 1 lux et le mode de lecture est continu. L'exemple montre, en utilisant la console série Arduino, chaque résultat obtenu à partir de la valeur mesurée.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
#include “BH1750.h” // Cargar los códigos de operación del BH1750
#include <Wire.h>
unsigned int lectura_BH1750;
unsigned int iluminacion;
//float iluminacion; // Mostrar el valor con decimales
long cronometro_lecturas=0;
long tiempo_transcurrido;
long cronometro_timeout_i2c;
void setup()
{
Serial.begin(9600);
Wire.begin();
delay(ESPERA_BH1750_0); // Espera inicial para estabilizar el BH1750
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.write(MEDIDA_CONTINUA_UN_LUX_BH1750);
Wire.endTransmission();
}
void loop()
{
tiempo_transcurrido=millis()–cronometro_lecturas;
if(tiempo_transcurrido>ESPERA_BH1750_0)
{
cronometro_lecturas=millis();
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.requestFrom(DIRECCION_BH1750_0,2);
do
{
tiempo_transcurrido=millis()–cronometro_timeout_i2c;
}
while(Wire.available()<2&&tiempo_transcurrido<TIMEOUT_I2C);
if(Wire.available()>1)
{
lectura_BH1750=Wire.read()<<8; // Leer el primer byte y rotarlo 8 bits
lectura_BH1750|=Wire.read(); // Leer el segundo byte y «juntarlo» con el anterior on OR
//iluminacion=lectura_BH1750/DIVISOR_PRECISION; // Resultado corregido y con decimales (mínimamente más preciso pero menos legible)
iluminacion=long(100.0*(float)lectura_BH1750/DIVISOR_PRECISION)/100; // Resultado corregido y sin decimales
Serial.print(“La iluminación es de “);
Serial.print(iluminacion);
Serial.println(” lux”);
}
}
}
|
Comme je l'ai dit ci-dessus, les modes de résolution 1 lux et 4 lux utilisent les 16 bits de données pour exprimer la mesure sous forme d'entier. En revanche, en mode 0,5 lux, le dernier bit représente une partie décimale, c'est-à-dire que la valeur qui contribue à la mesure totale est décalée d'une puissance de deux vers la droite. En mode 1 lux ou 4 lux, le dernier bit (LSB) vaut 20, l'avant-dernier 21, les 2 suivants2…en mode 0,5 lux, le dernier bit (LSB) vaut 2-1, l'avant-dernier 20, les 2 suivants1...
Selon cette structure de données, et considérant que deux lectures doivent être effectuées I2C d'un octet, pour obtenir la valeur 16 bits il faut charger les bits de poids fort de l'octet, les premiers à lire, et les faire pivoter de 8 bits vers la gauche dans le mode résolution 1 lux et dans le mode résolution 4 lux et seulement 7 bits à 0,5 lux. Pour unifier la manière de lire en mode 0,5 lux, vous pouvez charger l'octet de poids fort dans un entier non signé, faire pivoter 8 bits vers la gauche, charger l'octet de poids faible et faire pivoter l'entier non signé entier de 1 bit vers la gauche, en préservant la valeur de la partie décimale qui indique le LSB (bit le moins significatif) pour l'appliquer plus tard.
Logiquement, pour les modes 1 lux ou 4 lux il faut utiliser des entiers non signés (unsigned int) pour que Arduino ne réservez pas le MSB (bit le plus significatif) pour le signe et pouvoir opérer directement avec la vraie valeur de la mesure, et non avec un nombre négatif. Dans Arduino Due Ce n'est pas nécessaire puisque les entiers utilisent 32 bits, mais le même programme fonctionnera également s'il est également utilisé unsigned int.
Le code suivant montre comment le mode 0,5 lux serait utilisé
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
#include “BH1750.h” // Cargar los códigos de operación del BH1750
#include <Wire.h>
unsigned int lectura_BH1750;
//unsigned int iluminacion;
float iluminacion; // Mostrar el valor con decimales
long cronometro_lecturas=0;
long tiempo_transcurrido;
long cronometro_timeout_i2c;
bool parte_decimal;
void setup()
{
Serial.begin(9600);
Wire.begin();
delay(ESPERA_BH1750_0); // Espera inicial para estabilizar el BH1750
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.write(MEDIDA_CONTINUA_MEDIO_LUX_BH1750);
Wire.endTransmission();
}
void loop()
{
tiempo_transcurrido=millis()–cronometro_lecturas;
if(tiempo_transcurrido>ESPERA_BH1750_0)
{
cronometro_lecturas=millis();
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.requestFrom(DIRECCION_BH1750_0,2);
do
{
tiempo_transcurrido=millis()–cronometro_timeout_i2c;
}
while(Wire.available()<2&&tiempo_transcurrido<TIMEOUT_I2C);
if(Wire.available()>1)
{
lectura_BH1750=Wire.read()<<8; // Leer el primer byte y rotarlo 8 bits
lectura_BH1750|=Wire.read(); // Leer el segundo byte y «juntarlo» con el anterior on OR
parte_decimal=(lectura_BH1750<<15)>0;
lectura_BH1750>>=1;
iluminacion=((float)lectura_BH1750+(parte_decimal?0.5:0.0))/DIVISOR_PRECISION;
Serial.print(“La iluminación es de “);
Serial.print(iluminacion);
Serial.println(” lux”);
}
}
}
|
Poster un commentaire