O ambiente onde estou está sendo iluminado adequadamente ? Tenho bastante luz para trabalhar ou estudar ? Essas e outras questões podem ser respondidas com a ajuda do Sensor de luz TSL2561 lux luminosidade, que vamos utilizar juntamente com o Arduino e display Oled para montar um medidor de luz.
O sensor de luminosidade TSL2561 (datasheet) é um sensor avançado que detecta não só a faixa de luz normal, captada pelo olho humano, como também a luz infravermelha, em uma faixa de 0.1 à 40.000 lux. É um módulo extremamente econômico em termos de energia, consumindo apenas 0,5mA quando está recebendo luz, e 15µA em modo de espera (standby).
O que o sensor TSL2561 faz ?
Já falamos aqui do LDR (no post Controle de Luz utilizando LDR), que é um componente cuja resistência varia de acordo com a incidência de luz. Apesar de conseguirmos realizar algum tipo de medição com ele, não temos precisão na leitura.
O módulo TSL2561, por sua vez, é muito mais preciso, podendo detectar luz desde a faixa do infravermelho até a faixa total de luz (espectro) percebida pelo olho humano. Com o TSL2561, é possível calcular a quantidade exata de luz que atinge um certo ponto (lux), já que ele é um conversor que transforma a intensidade de luz em um sinal digital que pode ser interpretado por um microcontrolador.
Saber a quantidade de luz em um ponto/ambiente é importante pois, segundo os especialistas, luz demais causa uma sensação de desconforto, e pouca luz pode prejudicar (e geralmente prejudica) não só a sua visão mas também atrapalhar o desempenho das suas tarefas diárias. Assim, temos a seguinte recomendação de iluminância nos ambiente mais comuns, segundo as normas da ABNT:
- Escritório e biblioteca – 300 lux
- Cozinha e banheiro – 200 lux
- Sala estar, jantar e dormitório – 150 lux
- Hall, escada, despensa e garagem – 100 lux
Utilizando o módulo TSL2561 ligado em um Arduino, você pode conferir se as especificações de luminosidade na sua casa ou escritório estão corretas.
Pinagem do módulo TSL2561
Abaixo podemos ver a disposição dos pinos do módulo, tanto de alimentação e sinal, como também da seleção de endereço I2C (Addr). Se você preferir, pode setar o endereço I2C de forma permanente, soldando os terminais na parte de trás da placa.
- Vcc – Alimentação 3.3 ou 5V
- GND – GND
- 3vo – Saída 3.3V do regulador de tensão do módulo. Suporta até 100mA
- Addr – Seleção do endereço I2C: 0x29 (pino em nível 0), 0x49 (nível 1) ou 0x39 (desligado / floating)
- Int – Interrupt Output – é um pino específico, acionado quando a luminosidade alcança um determinado nível (threshold)
- SDA – I2C – Data
- SCL – I2C – Clock
Conexão do sensor ao Arduino
Para ligar o TSL2561 ao Arduino Uno vamos utilizar somente os pinos de alimentação e interface I2C (portas analógicas A4 e A5), deixando o pino ADDR sem conexão (floating), utilizando assim o endereço 0x39.
O módulo pode ser ligado diretamente aos pinos SCL e SDA do Arduino, pois ele é compatível tanto com nível de sinal de 3.3V como de 5V.
O display que usamos é um display OLED 0.96″ com interface I2C, ligado em 3.3V assim como o módulo TSL2561. Esse display tem uma pequena faixa na parte superior com os pixels em amarelo, e o restante do display tem os pixels na cor azul.
Programa módulo sensor de luz TSL2561 com arduino
Para esse programa vamos precisar de 3 bibliotecas, sendo duas para o sensor de luz e uma para o display Oled:
Adafruit TSL2561 V2 (download)
Adafruit Sensor Library (download)
U8Glib (download)
Baixe as três bibliotecas, descompacte e coloque-as na pasta LIBRARIES da IDE do Arduino.
O programa utiliza como base o programa de exemplo sensorapi da biblioteca Adafruit TSL2561 para ler os dados do sensor e converter em lux. Essas informações são exibidas no display Oled utilizando as funções da biblioteca gráfica U8Glib.
Na linha 13 do programa você define qual endereço I2C usar, substituindo TSL2561_ADDR_FLOAT por TSL2561_ADDR_HIGH (para o endereço 0x49) ou TSL2561_ADDR_LOW (para o endereço 0x29). Não se esqueça, claro, de enviar o sinal adequado para o pino ADDR.
//Programa: Medidor de Luminosidade Lux com sensor TSL2561
//Autor: Arduino e Cia
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>
#include <U8glib.h>
//Definicoes do display Oled
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);
//Definicoes do sensor TSL2561
Adafruit_TSL2561_Unified tsl=Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT,12345);
int valor = 0;
String str;
int tamanho;
void draw()
{
//Comandos graficos para o display devem ser colocados aqui
u8g.drawRFrame(0, 16, 128, 48, 4);
u8g.drawRFrame(0, 0, 128, 16, 4);
u8g.setFont(u8g_font_8x13B);
u8g.setColorIndex(0);
u8g.setColorIndex(1);
u8g.drawStr( 30, 13, "Lux Meter");
u8g.setFont(u8g_font_fur25);
str = String(valor);
tamanho = str.length();
u8g.setPrintPos(64-(tamanho*10), 53);
u8g.print(valor);
}
void displaySensorDetails(void)
{
//Informacoes basicas do sensor TSL2561
sensor_t sensor;
tsl.getSensor(&sensor);
Serial.println("------------------------------------");
Serial.print ("Sensor: "); Serial.println(sensor.name);
Serial.print ("Driver Ver: "); Serial.println(sensor.version);
Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id);
Serial.print ("Max Value: "); Serial.print(sensor.max_value);
Serial.println(" lux");
Serial.print ("Min Value: "); Serial.print(sensor.min_value);
Serial.println(" lux");
Serial.print ("Resolution: "); Serial.print(sensor.resolution);
Serial.println(" lux");
Serial.println("----------------------------------");
Serial.println("");
delay(500);
}
/**************************************************************************/
/*
Configures the gain and integration time for the TSL2561
*/
/**************************************************************************/
void configureSensor(void)
{
/* You can also manually set the gain or enable auto-gain support */
/* No gain. use in bright light to avoid sensor saturation */
// tsl.setGain(TSL2561_GAIN_1X);
/* 16x gain. use in low light to boost sensitivity */
// tsl.setGain(TSL2561_GAIN_16X);
/* Auto-gain. switches automatically between 1x and 16x */
tsl.enableAutoRange(true);
/* Changing the integration time gives you better
sensor resolution (402ms = 16-bit data) */
/* fast but low resolution */
tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);
/* medium resolution and speed */
// tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);
/* 16-bit data but slowest conversions */
// tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_402MS);
/* Update these values depending on what you've set above! */
Serial.println("------------------------------------");
Serial.print ("Gain: "); Serial.println("Auto");
Serial.print ("Timing: "); Serial.println("13 ms");
Serial.println("------------------------------------");
}
void setup(void)
{
Serial.begin(9600);
Serial.println("Light Sensor Test"); Serial.println("");
//Inicializa o sensor TSL
if (!tsl.begin())
{
Serial.print("TSL2561 nao detectado,verifique a conexao e o endereco I2C");
while (1);
}
//Exibe as informacoes basicas do sensor TSL
displaySensorDetails();
//Configura o sensor TSL
configureSensor();
Serial.println("");
if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
u8g.setColorIndex(255); // white
}
else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
u8g.setColorIndex(3); // max intensity
}
else if ( u8g.getMode() == U8G_MODE_BW ) {
u8g.setColorIndex(1); // pixel on
}
else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
u8g.setHiColorByRGB(255, 255, 255);
}
}
void loop(void)
{
Calcula_Lux();
//Chama a rotina de desenho na tela
u8g.firstPage();
do
{
draw();
}
while ( u8g.nextPage() );
delay(150);
}
void Calcula_Lux()
{
sensors_event_t event;
tsl.getEvent(&event);
//Mostra os resultados no serial monitor
//Intensidade da Luz medida em Lux
if (event.light)
{
valor = event.light;
Serial.print(event.light); Serial.println(" lux");
}
else
{
Serial.println("Sensor overload");
}
delay(250);
}
Caso você não possua ou não queira utilizar o display, pode conferir a medição da luminosidade e também outras informações do sensor, como ganho (gain) e nível de resolução, no Serial Monitor:
Abaixo você confere um vídeo do circuito em funcionamento:
Se você gostou deste post do sensor TSL2561 com Arduino, dê uma olhada nos outros posts utilizando módulos aqui mesmo no Arduino e Cia!