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.

Sensor de lux luminosidade TSL2561 Arduino

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.

TSL2561 Lux Sensor
  • 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.

Arduino Uno - Oled - Sensor TSL2561

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:

TSL2561 - 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!

Avalie este post!