BH1750. Ambient light sensor na may I2C bus.
Ang BH1750 ay isang ambient lighting sensor na may makatwirang mataas na resolution at sensitivity. Ito ay kumikilos sa harap ng nakikitang liwanag sa paraang maihahambing sa mata ng tao at hindi apektado ng infrared radiation at hindi rin ito nakasalalay sa temperatura ng kulay ng uri ng pag-iilaw, ibig sabihin, ito ay gumagana nang maayos sa natural na liwanag at may iba't ibang uri ng artipisyal na pag-iilaw. Ito ay nakikipag-usap nang digital sa microcontroller, kasama ang I2C bus, kaya ito ay lumalaban sa interference kung ito ay nakalagay sa isang tiyak na distansya mula sa circuit na nagbabasa nito. Ang oras ng pagtugon nito ay medyo mababa, mas mababa sa 200 ms sa pinaka-hindi kanais-nais na mga pangyayari.
Mula sa elektronikong pananaw, ang pagpapatupad nito ay napaka-simple. Ikonekta lamang ang kapangyarihan (sa pagitan ng 2,4V at 3,6V) at ang I2C bus. Opsyonal, maaaring baguhin ang address ng bus upang kumonekta sa dalawang device (na may ADDR sa mababang antas ito ay 0B0100011 o 0x23 at sa ADDR sa mataas na antas ito ay 0B1011100 o 0x5C) at ang linya ng VDI ay maaaring gamitin para sa pag-reset ng function sa microcontroller.
Para ikonekta ang BH1750 sa Arduino, bilang karagdagan sa pinapagana ng 3,3 V output, pinakatama na gumamit ng level converter bilang karagdagan sa pull-up resistors para sa I2C bus. Bagama't susuportahan ng component ang direktang koneksyon sa bus I2C bus Hindi ipinapayong sukatin ang isang circuit nang hindi isinasaalang-alang ang pag-convert ng antas.
Dahil sa katanyagan nito, na dahil sa pagiging napakamura na may kaugnayan sa katumpakan nito, mayroong ilang mga module, tulad ng kilalang GY-30, na makikita sa litrato sa simula. Upang ikonekta ang mga ito nang mas kumportable kapag nagpo-prototyping gamit ang isang microcontroller, kadalasang kasama nila ang mga level converter para sa I2C bus at mga regulator ng boltahe upang paganahin ang mga ito ng mas mataas na boltahe (hanggang 5V) sa halip na ang 3,3V na output ng Arduino.
Ang BH1750 ay may dalawang mode ng pagbabasa, tuloy-tuloy at indibidwal, na tumutugma sa dalawang estado, aktibo at mahina ang lakas o pagtulog. Habang kung gagamitin ang continuous reading mode, ang BH1750 ay mananatiling aktibo pagkatapos ng sampling, pagkatapos magsagawa ng indibidwal na pagsukat ay awtomatiko itong papasok sa sleep at low power mode. Ang unang pagbabasa sa tuloy-tuloy na mode ay tumatagal ng maximum na 180 ms at ang mga kasunod ay nasa pagitan ng 16 ms at 120 ms depende sa resolution.
Ang sensor ay may kakayahang magsukat sa mga pagitan (resolution) na 4 lux, 1 lux at 0,5 lux. Inirerekomenda ng BH1750 sa data sheet nito na gamitin ang resolution na 1 lux, na nagbibigay-daan sa mga illumination na mas mababa sa 10 lux na makilala (na tumutugma sa twilight) at mas immune sa ingay na maaaring makaapekto sa pagsukat.
Ang mga resolution ng 1 lux at 4 na lux ay gumagamit ng 16 bits ng data upang kumatawan sa integer na bahagi upang ang maximum na sukat na 65535 lux ay maaaring makamit (maaraw na araw nang walang direktang liwanag). Ang 0,5 lux mode ay gumagamit ng hindi bababa sa makabuluhang bit para sa decimal na bahagi (mga sukat mula 0,5 lux hanggang 0,5 lux) kaya sa natitirang 15 bits posibleng kumatawan sa maximum na halaga na 32767 lux (exterior na walang direktang liwanag)
Karaniwan, ang optical window ayon sa kung saan ang ambient light ay sinusukat ay tumutugma sa buong nakikitang spectrum at ang layunin ay upang makamit ang isang sensitivity distribution dito na maihahambing sa mga tao. Kung ang optical window ay nabawasan (ang ilaw ay sinusukat sa isang mas mababang wavelength range) ang sensitivity ng BH1750 ay maaaring tumaas (hanggang sa 0,11 lux) na may mode ng pagkansela ng pagsasaayos ng impluwensya ng optical window sa pamamagitan ng pagtaas ng oras ng pagbabasa sa proporsyon. Dahil sa espesyal na (napakalaki) na mode na ito, ang mga hiwalay na pagbabasa ay kinukuha, ang konteksto ay dapat payagan ito nang hindi partikular na binabago ang mga kondisyon ng pagsukat (halimbawa, ang sensor ay dapat manatiling napaka-stable, hindi ito dapat lumipat sa isang lugar na may iba't ibang mga kondisyon ng pag-iilaw)
Mga Code ng Operasyon ng BH1750
Estado
5>
-
0B00000000(0x00) Mababang kapangyarihan o idle mode. -
0B00000001(0x01) Nakabukas. -
0B00000111(0x07) I-reset. Ni-clear ang mga log ng data ng BH1750.
Paglutas
5>
-
0B00010011(0x13) Patuloy na pagsukat sa 4 na lux na resolution (sa pagitan ng 16 ms at oras ng pagbabasa) -
0B00010000(0x10) Patuloy na pagsukat sa 1 lux na resolution (120 ms reading time) -
0B00010001(0x11) Patuloy na pagsukat sa 0,5 lux na resolution (120 ms reading time) -
0B00100011(0x23) Isang pagsukat sa 4 lux na resolution (16 ms reading time) -
0B00100000(0x20) Isang pagsukat sa 1 lux na resolution (120 ms reading time) -
0B00100001(0x21) Isang pagsukat sa 0,5 lux na resolution (120 ms reading time)
Pagsasaayos para sa pagbabago sa optical window
5>
-
0B011MT[0,1,2,3,4] Mababang bit ng rehistro ng MTREG (Measurement Time REGIster). -
0B01000MT[5,6,7] MTREG register high bit.
Basahin ang BH1750 mula sa Arduino
Upang sukatin ang ambient lighting gamit ang BH1750 mula sa Arduino ang aklatan ay ginagamit kawad na namamahala sa mga komunikasyon sa I2C bus. Ang proseso ay ang karaniwan sa ganitong uri ng mga komunikasyon, una ang mga ito ay isinaaktibo (isang beses sa programa) kasama Wire.begin(), ang komunikasyon sa BH1750 ay nagsisimula sa Wire.beginTransmission() at ang iyong address I2C (0x5C o 0x23 depende sa kung mataas o mababa ang ADDR ayon sa pagkakabanggit), ito ay na-configure sa pamamagitan ng pagpapadala ng kaukulang code na may Wire.write() at inilabas ang bus kasama ng Wire.endTransmission()
|
15
|
Wire.begin();
|
|
17
18
19
|
Wire.beginTransmission(DIRECCION_BH1750_0);
Wire.write(MEDIDA_CONTINUA_UN_LUX_BH1750);
Wire.endTransmission();
|
Kung ang isa sa mga patuloy na mode ng pagbasa ay ginagamit, ang Wire.beginTransmission() ay ginagamit upang makuha ang data na may address I2C naaayon sa pag-access sa BH1750, sinenyasan ka para sa dalawang byte (resolution ay 16 bits) na may Wire.requestFrom() na binabasa, ginagamit Wire.read(), at nilo-load sa isang unsigned integer, pinapaikot ang unang byte ng 8 bits. Ang bus ay kasunod na inilabas kasama ng Wire.endTransmission(). Ang huling resulta ay nakuha sa pamamagitan ng paghahati sa ibinalik na halaga sa pamamagitan ng precision factor (1,2 kung ang optical window ay hindi binago)
|
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
|
Kung gagamitin ang individual readings mode, papasok ang BH1750 sa sleep mode. Para bumalik sa active mode, maaaring magpadala ng configuration (kaparehong reading mode o bago) o power-on code (0x01). Maaaring gamitin ang shutdown code (1750x0) upang pilitin ang BH00 sa sleep mode.
Mahalagang igalang ang oras ng pagbabasa ng sensor, na nakasalalay sa resolusyon. Kung ang paghihintay ay hindi kritikal, maaari itong pagsamahin sa isang halaga para sa lahat ng mga kaso na maaaring bahagyang mas malaki kaysa sa maximum na inaasahan upang matiyak na makumpleto ang pagbabasa.
Upang gawing mas komportable ang pagsulat ng code para sa BH1750 Arduino, ang mga pinaka-nauugnay na code ng pagpapatakbo ay matatagpuan sa sumusunod na dokumento ng header.
|
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
|
Ipinapakita ng sumusunod na halimbawang code ang pinakakaraniwang mode ng pagbasa sa light sensor I2C BH1750. Ang resolution ay 1 lux at tuloy-tuloy ang reading mode. Ipinapakita ng halimbawa, gamit ang serial console Arduino, bawat resulta na nakuha mula sa sinusukat na halaga.
|
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”);
}
}
}
|
Tulad ng sinabi ko sa itaas, ang parehong 1 lux at 4 na lux na resolution mode ay gumagamit ng 16 bits ng data upang ipahayag ang pagsukat bilang isang integer. Sa kabilang banda, sa 0,5 lux mode, ang huling bit ay kumakatawan sa isang decimal na bahagi, iyon ay, ang halaga na nag-aambag sa kabuuang pagsukat ay inilipat sa pamamagitan ng kapangyarihan ng dalawa sa kanan. Sa 1 lux o 4 lux mode ang huling bit (LSB) ay nagkakahalaga ng 20, ang penultimate 21, ang susunod na 22…sa 0,5 lux mode ang huling bit (LSB) ay nagkakahalaga ng 2-1, ang penultimate 20, ang susunod na 21...
Ayon sa istruktura ng data na ito, at isinasaalang-alang na dapat gawin ang dalawang pagbabasa I2C ng isang byte, upang makuha ang 16-bit na halaga kailangan mong i-load ang pinakamahalagang bits ng byte, ang mga unang babasahin, at paikutin ang mga ito ng 8 bits pakaliwa sa 1 lux resolution mode at sa 4 lux resolution mode at 7 bits lang sa 0,5 lux. Upang pag-isahin ang paraan ng pagbabasa sa 0,5 lux mode maaari mong i-load ang pinakamahalagang byte sa isang unsigned integer, i-rotate ang 8 bits sa kaliwa, i-load ang hindi bababa sa makabuluhang byte at i-rotate ang buong unsigned integer 1 bit sa kaliwa. pakanan, pinapanatili ang halaga ng bahaging desimal na nagsasaad ng LSB (least significant bit) para ilapat ito mamaya.
Sa lohikal na paraan, para sa 1 lux o 4 na lux mode ay kinakailangan na gumamit ng mga unsigned integer (unsigned int) para saan Arduino huwag ireserba ang MSB (pinaka makabuluhang bit) para sa sign at maaaring gumana nang direkta sa totoong halaga ng pagsukat, hindi sa isang negatibong numero. Sa Arduino Dahil hindi kinakailangan dahil ang mga integer ay gumagamit ng 32 bits, ngunit ang parehong programa ay gagana rin kung gagamitin din unsigned int.
Ipinapakita ng sumusunod na code kung paano gagamitin ang 0,5 lux mode
|
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”);
}
}
}
|
Post Komento