Sensore di luce TSL2561

ultimo aggiornamento 1 maggio 2019


JLCPCB - 2$ per prototipi di PCB, di qualsiasi colore. Produzione in 24 ore!
L'Azienda di prototipi PCB più popolare, con oltre 700.000 clienti in tutto il mondo!
Recati presso la JLCPCB, riceverai regali e coupon gratuiti
presso Maker Faire Rome il 18-20 ottobre


Indice

Descrizione

Il sensore di luminosità TSL2561 prodotto dalla AMS è un sensore avanzato di luce digitale , ideale per l'uso in una vasta gamma di condizioni di luce.


Il sensore si può acquistare sul sito Homotix.

Rispetto alle cellule CdS a basso costo, questo sensore è più preciso, consentendo misure direttamente in lx e può essere configurato per differenti range di misura in modo da rilevare gamme di luce comprese tra 0,1 - 40.000 lx.
Questo sensore è che contiene entrambi i sensori per la misura sia dello spettro totale che nell'infrarosso.
Ciò significa che è possibile misurare separatamente gli infrarossi, che lo spettro visibile alla vista umana.
La maggior parte dei sensori è in grado di rilevare solo uno o l'altro, che non  rappresentano accuratamente ciò che gli occhi umani vedono (dal momento che non siamo in grado di percepire la luce a infrarossi che viene rilevato dalla maggior parte dei fotodiodi)
Il sensore ha una interfaccia digitale (I2C), ed è possibile selezionare uno dei tre indirizzi in modo da poter gestire sino a tre sensori.
All'interno del sensore è già presente un convertitore ADC, il che significa che è possibile utilizzarlo con qualsiasi microcontrollore, anche se non dispone di ingressi analogici.
L'assorbimento di corrente è estremamente basso circa 0,5 mA quando attivo e meno di 15 uA in modalità powerdown.

OurPCB, your most reliable PCB and PCBA supplier.

Focusing on PCB Prototype and PCB Assembly Turnkey Services.

One-Stop Wire Harness & Cable Assemblies Solution

NOTA:
Ci si potrebbe chiedere se sia ragionevole collegare un un sensore da 3,3 V, come TSL2561 su un bus di dati 5.0V come Arduino Micro.
In questo caso particolare, il modulo I2C utilizza una resistenza di pullup per tornare alla tensione di alimentazione di 3.3V, i dati sono inviati a 3.3V. Tutto andrà bene finché tutti i sensori sul bus I2C operano a 3.3v.
Tuttavia fatta attenzione a non usare un dispositivo I2C con pullup a 5.0V (come DS1307) insieme ad un dispositivo di 3.3V come TSL2561.

Il sensore utilizzato è una vecchia versione, quella tuttora in vendita risulta già montato su un piccolo circuito prodotto dalla Adafruit codice (PRODUCT ID: 439) èd è dotata di traslatori di livelli e di regolatore di tensione, che permettono di utilizzare i modulo direttamente con la tensione di 5V.

Altre versioni del sensore

Sensore di Luminosità TSL2561 Sparkfun

Sensore di Luminosità TSL2561 Elecrow

 

Caratteristica sensore

Approssima la risposta dell'occhio umano
Misura con precisione illuminamento in diverse condizioni di illuminazione

Gamma dinamica (Lx): da 0,1 a 40.000 Lx
Campo di temperatura:  da -30 a 80 °C
Campo di tensione: 2.7-3.6V
Interfaccia:  I2C
TSL2561 LIGHT-TO-DIGITAL CONVERTER
Piedinatura Datasheet Foto dell'integrato

Collegamento ad Arduino Micro

In questo esempio vediamo come collegare il sensore TSL2561 ad una scheda ARDUINO MICRO, questo per realizzare un interruttore crepuscolare, quando la luminosità scende sotto il valore di 200 lx (valore che può essere modificato all'interno del programma) viene attivato un relè, per esempio un KY-019 5V relay module che a sua volta può comandare l'accensione di una lampada collegata alle rete elettrica.

Schema di collegamento del sensore TSL2561

 
Pin Arduino Micro Pin Sensore TSL2561 Pin relè
#2 SDA  
#3 SCL  
#5   IN
+ 3.3V VCC + 3.7V
+ 5V   VCC
GND GND GND

 
Arduino Micro Sensore di luce TSL2561
KY-019 5V relay module Breadboard
 
Cavetti per Breadboard di vari colori  

Sketch

Per il test del sensore può essere utilizzato il programma sotto riportato che rappresenta un interruttore crepuscolare, quando la luminosità scende sotto il valore di 200 lx (valore che può essere modificato all'interno del programma) viene attivato l'uscita digitale che attiva il relè
Per la lettura dei dati del sensore TLS5861, occorre, se non lo si è mai utilizzato caricare l'apposita libreria, per cui andare al menu Sketch-> #includi libreria  -> Gestione librerie

 

ricercare TLS2561 e installare la libreria Adafruit TLS2561 By Adafruit, per il funzionamento occorre anche installare la libreria  Adafruit_Sensor

Le due librerie sono scaricabili dai seguenti link

https://github.com/adafruit/Adafruit_TSL2561 oppure Adafruit_TSL2561.zip

https://github.com/adafruit/Adafruit_Sensor oppure Adafruit_Sensor.zip

Programma  di test

/*
  crepuscolare_TSL2561.ino
  Il programma rappresenta un sensore crepuscolare, quando il sensore rileva un
  valore di luminosità sotto la soglia impostata attiva un relè a cui
  può essere collegata una lampada.

  Sono utilizzati i seguenti pin
  Pin +5V           -> Alimentazione relè
  Pin +3.3 V        -> Alimentazione sensore TSL2561
  Pin GND           -> GND sensore TSL2561 e relè
  Pin Digitale 2    -> SDA sensore TSL2561 (Analogico A4 con Arduino UNO)
  Pin Digitale 3    -> SCL sensore TSL2561 (Analogico A5 con Arduino UNO)
  Pin Digitale 5    -> Relè

  Creato il 01/01/2019 da Adriano Gandolfo
  Modificato 01/05/2019 da Adriano Gandolfo
  Sito web https://www.adrirobot.it
  Blog https://it.emcelettronica.com/author/adrirobot
  Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
  Istagram https://www.instagram.com/adrirobot/
  This example code is in the public domain.
*/
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>

#define relePin 5 //Pin collegamento relè

Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);

/**************************************************************************
  Sono mostrate alcune informazioni sul sensore
**************************************************************************/
void displaySensorDetails(void)
{
  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 */
  // tsl.setGain(TSL2561_GAIN_1X);  /* No gain ... use in bright light to avoid sensor saturation */
  // tsl.setGain(TSL2561_GAIN_16X); /* 16x gain ... use in low light to boost sensitivity */
  tsl.enableAutoRange(true);        /* Auto-gain ... switches automatically between 1x and 16x */

  /* Changing the integration time gives you better sensor resolution (402ms = 16-bit data) */
  tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
  // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);  /* medium resolution and speed   */
  // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_402MS);  /* 16-bit data but slowest conversions */

  /* 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("------------------------------------");
}

/**************************************************************************
  Funzione di configurazione di Arduino (chiamata automaticamente all'avvio)
**************************************************************************/
void setup(void)
{
  Serial.begin(9600);
  pinMode(relePin, OUTPUT); // Impostazione della porta come uscita
  Serial.println("Light Sensor Test"); Serial.println("");

  /* Initialise the sensor */
  //use tsl.begin() to default to Wire,
  //tsl.begin(&Wire2) directs api to use Wire2, etc.
  if (!tsl.begin())
  {
    /* There was a problem detecting the TSL2561 ... check your connections */
    Serial.print("Ooops, no TSL2561 detected ... Check your wiring or I2C ADDR!");
    while (1);
  }

  /* Display some basic information on this sensor */
  displaySensorDetails();

  /* Setup the sensor gain and integration time */
  configureSensor();

  /* We're ready to go! */
  Serial.println("");
}

/**************************************************************************
  Codice del programma crepuscolare
**************************************************************************/
void loop(void)
{
  /* Get a new sensor event */
  sensors_event_t event;
  tsl.getEvent(&event);
  // Controllo ativazione del relè in base al valore di luminosità letto
  if (event.light < 200)
  {
    Serial.print (event.light);
    digitalWrite(relePin, HIGH); //Attiva l'uscita che eccita il relè
    Serial.println(" - ATTIVO USCITA RELE'");
  } else {
    Serial.print (event.light);
    digitalWrite(relePin, LOW); //Disattiva l'uscita che diseccita il relè
    Serial.println(" - DISATTIVO USCITA RELE'");
  }
  delay(1000); //Pausa tra le letture del sensore
}

Collegamento a modulo WeMos D1 mini

Il Modulo WeMos D1 mini è basato sul microcontrollore Wi-Fi ESP8266 ESP-12F che può essere programmato utilizzando l'IDE di Arduino oppure NodeMCU. La semplicità della programmazione che può essere effettuata anche in modalità wireless e l'ampia disponibilità di shield aggiuntivi permettono di sviluppare il proprio progetto di "Internet delle cose" in tempi estremamente rapidi.
Il modulo WeMos D1 mini  è dotato di una interfaccia USB realizzata tramite il convertitore seriale-USB CH340
Dal connettore USB viene anche prelevata l'alimentazione a 5V, un regolatore interno (tipo RT9013) si occupa di generare l'alimentazione a 3,3V per il modulo ESP-12F. Per evitare confusione tutti i pin di I/O sono chiaramente etichettati.
Nota: Tutti gli I/O supportano una tensione massima di 3,3V

Il modulo WeMos D1 mini può essere acquistato sul sito Homotix

Schema di collegamento del sensore TSL2561

Pin WeMos D1 Mini Pin Sensore TSL2561
D2 SDA
D1 SCL
+ 3.3V VCC
GND GND

 
WeMos D1 mini Sensore di luce TSL2561
Breadboard Cavetti per Breadboard di vari colori

Listato del programma

Nel programma di test tramite il modulo WeMos D1 mini del sensore TLS2561, il valore della luminosità viene mostrato all'interno della finestra del Monitor seriale. La lettura è effettuata  ogni 250 ms.
I pin SCL e SDA del sensore sono collegati rispettivamente a D1 e D2 del modulo WeMos D1 mini e gestiti dalla libreria Wire.

Programma  di test

/*
  wemos_d1_mini_TSL2561.ino
  In questo esempio utilizziamo il modulo WeMos D1 mini
  per leggere i dati di luminosità forniti
  dal sensore TSL2561.

  Sono utilizzati i seguenti pin
  Pin +3.3V   -> Alimentazione TSL2561
  Pin GND     -> GND TSL2561
  Pin D1      -> pin SCL TSL2561
  Pin D2      -> pin SDA TSL2561

  Creato il 14/8/2017 da Adriano Gandolfo
  Sito web http://www.adrirobot.it
  Blog http://it.emcelettronica.com/author/adrirobot
  Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
  Istagram https://www.instagram.com/adrirobot/
  This example code is in the public domain.
*/

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>

Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);

void setup(void)
{
  Serial.begin(9600);
  Serial.println("Test sensore TSL2561");
  Serial.println("");

  /* Iinzializzazione sensore */
  if (!tsl.begin())
  {
    Serial.print("TSL2561 non trovato");
    while (1);
  }

  tsl.enableAutoRange(true);
  tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);

  Serial.println("");
}

void loop(void)
{
  /* Get a new sensor event */
  sensors_event_t event;
  tsl.getEvent(&event);

  /* Mostra il risultato (luce misurata in lx) */
  if (event.light)
  {
    Serial.print(event.light);
    Serial.println(" lx");
  }
  else
  {
    Serial.println("Sensore fuoriscala");
  }
  delay(250);
}

 

Elenco revisioni:

01/05/2019

Aggiornato programma Crepuscolare

17/09/2017

Inserito gestione del sensore tramite modulo WeMos D1 mini

30/04/2017

Emissione preliminare