MicroPython : capteur de lumière ambiante BH1750 avec ESP32/ESP8266

MicroPython : capteur de lumière ambiante BH1750 avec ESP32/ESP8266

Le BH1750 est un capteur de lumière ambiante 16 bits. Dans ce didacticiel, vous apprendrez à utiliser le capteur de lumière ambiante BH1750 avec les cartes ESP32 et ESP8266 programmées avec le firmware MicroPython. Vous apprendrez à câbler le capteur aux cartes ESP, à installer les bibliothèques requises et à obtenir des mesures de lumière ambiante en Lux (l’unité standard d’éclairement).

Capteur de lumière ambiante MicroPython BH1750 avec ESP32 ESP8266 NodeMCU

Vous utilisez l’IDE Arduino ? Suivez plutôt les tutoriels suivants :

Table des matières:

Ce didacticiel couvre les sujets suivants :

Conditions préalables

Pour suivre ce tutoriel, vous devez installer le firmware MicroPython sur vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre tableau. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

  • ThonnyIDE :
  • L’EDI uPyCraft :

En savoir plus sur MicroPython : Programmation MicroPython avec ESP32 et ESP8266

Pièces requises

Pour suivre ce tutoriel vous avez besoin de la pièce suivante :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

MicroPython capteur de lumiere ambiante BH1750 avec ESP32ESP8266

Présentation du capteur de lumière ambiante BH1750

Le BH1750 est un capteur de lumière ambiante 16 bits qui communique via le protocole I2C. Il produit des mesures de luminosité en lux (unité d’éclairement dérivée du SI). Il peut mesurer un minimum de 1 lux et un maximum de 65 535 lux.

Le capteur peut se présenter sous différents formats de carte de dérivation. Voir les photos ci-dessous. Les deux images représentent un capteur BH1750.

Cartes de dérivation du capteur de lumière ambiante BH1750

Caractéristiques du BH1750

Voici une liste des fonctionnalités du capteur BH1750. Pour plus d’informations, consultez la fiche technique du capteur BH1750.

  • Interface de bus I2C
  • La responsabilité spectrale correspond approximativement à la réponse de l’œil humain
  • Convertisseur d’éclairement en numérique
  • Plage : 1 – 65 535 lux
  • Faible courant grâce à la fonction de mise hors tension
  • Fonction de rejet du bruit léger 50 Hz / 60 Hz
  • Il est possible de sélectionner 2 adresses esclaves I2 C différentes
  • Petite variation de mesure (+/- 20%)
  • L’influence de l’infrarouge est très faible
  • Prend en charge le mode de mesure continue
  • Prend en charge le mode de mesure unique

Modes de mesure

Le capteur prend en charge deux modes de mesure différents : le mode de mesure continue et le mode de mesure unique. Chaque mode prend en charge trois modes de résolution différents.

Mode basse résolution Précision 4 lux Temps de mesure 16 ms
Mode haute résolution Précision 1 lux Temps de mesure de 120 ms
Mode haute résolution 2 Précision de 0,5 lux Temps de mesure de 120 ms

En mode de mesure continue, le capteur mesure en continu les valeurs de lumière ambiante. En mode de mesure unique, le capteur mesure une fois la valeur de la lumière ambiante, puis passe en mode mise hors tension.

Applications

Capteur de lumière ambiante BH1750

Le BH1750 est un capteur de lumière ambiante qui peut donc être utilisé dans une grande variété de projets. Par exemple:

  • pour détecter s’il fait jour ou nuit;
  • pour régler ou allumer/éteindre la luminosité des LED en fonction de la lumière ambiante ;
  • pour régler la luminosité des écrans LCD et de l’écran ;
  • pour détecter si une LED est allumée ;
  • …

Brochage du BH1750

Brochage du capteur de lumière ambiante BH1750

Voici le brochage du BH1750 :

VCC Alimente le capteur (3,3 V ou 5 V)
GND GND commun
SCL Broche SCL pour la communication I2C
SDA (Données) Broche SDA pour la communication I2C
AJOUTER* Sélectionne l’adresse

La broche ADD est utilisée pour définir l’adresse du capteur I2C. Si la tension sur cette broche est inférieure à 0,7 VCC (la broche est laissée flottante ou connectée à GND), l’adresse I2C est 0x23. Mais si la tension est supérieure à 0,7xVCC (la broche est connectée à VCC), l’adresse est 0x5C. En résumé:

  • AJOUTER une broche flottante ou connectée à GND → adresse : 0x23
  • AJOUTER une broche connectée à VCC → adresse : 0x5C

Câblage du BH1750 à l’ESP32 ou à l’ESP8266

Le capteur de lumière ambiante BH1750 prend en charge l’interface I2C. Vous pouvez connecter le capteur BH1750 à l’ESP32/ESP8266 en utilisant les broches I2C par défaut :

BH1750 ESP32 ESP8266
VCC 3,3 V 3,3 V
GND GND GND
SCL GPIO22 GPIO5 (D1)
SDA (Données) GPIO21 GPIO4 (D2)
AJOUTER* Ne vous connectez pas Ne vous connectez pas
En ne connectant pas la broche ADD, nous sélectionnons l’adresse I2C 0x23. Connectez-le à 3,3 V pour sélectionner l’adresse 0x5C à la place.

Vous pouvez également utiliser les diagrammes schématiques suivants comme référence.

Schéma – ESP32 avec BH1750

Circuit de schéma de câblage ESP32 BH1750

Schéma – ESP8266 NodeMCU avec BH1750

Schéma de câblage ESP8266 NodeMCU BH1750

Bibliothèque MicroPython BH1750

Pour lire à partir du capteur BH1750, nous utiliserons une bibliothèque externe qui ne fait pas partie par défaut de la bibliothèque MicroPython standard.

Ouvrez le lien suivant et copiez le code de la bibliothèque dans Thonny IDE :

Suivez les étapes suivantes pour télécharger la bibliothèque sur votre carte ESP32 ou ESP8266 :

1) Copiez le code de la bibliothèque dans un nouveau fichier. Le code de la bibliothèque bh1750.py peut être trouvé ici.

# forked from: https://github.com/PinkInk/upylib/tree/master/bh1750
"""
Micropython BH1750 ambient light sensor driver.
"""

from utime import sleep_ms


class BH1750():
    """Micropython BH1750 ambient light sensor driver."""

    PWR_OFF = 0x00
    PWR_ON = 0x01
    RESET = 0x07

    # modes
    CONT_LOWRES = 0x13
    CONT_HIRES_1 = 0x10
    CONT_HIRES_2 = 0x11
    ONCE_HIRES_1 = 0x20
    ONCE_HIRES_2 = 0x21
    ONCE_LOWRES = 0x23

    # default addr=0x23 if addr pin floating or pulled to ground
    # addr=0x5c if addr pin pulled high
    def __init__(self, bus, addr=0x23):
        self.bus = bus
        self.addr = addr
        self.off()
        self.reset()

    def off(self):
        """Turn sensor off."""
        self.set_mode(self.PWR_OFF)

    def on(self):
        """Turn sensor on."""
        self.set_mode(self.PWR_ON)

    def reset(self):
        """Reset sensor, turn on first if required."""
        self.on()
        self.set_mode(self.RESET)

    def set_mode(self, mode):
        """Set sensor mode."""
        self.mode = mode
        self.bus.writeto(self.addr, bytes([self.mode]))

    def luminance(self, mode):
        """Sample luminance (in lux), using specified sensor mode."""
        # continuous modes
        if mode & 0x10 and mode != self.mode:
            self.set_mode(mode)
        # one shot modes
        if mode & 0x20:
            self.set_mode(mode)
        # earlier measurements return previous reading
        sleep_ms(24 if mode in (0x13, 0x23) else 180)
        data = self.bus.readfrom(self.addr, 2)
        factor = 2.0 if mode in (0x11, 0x21) else 1.0
        return (data[0]<<8 | data[1]) / (1.2 * factor)

Afficher le code brut

Bibliothèque micropython BH1750 sur Thonny IDE

2) Allez dans Fichier > Enregistrer sous…

Thonny IDE ESP32 ESP8266 MicroPython Enregistrer la bibliothèque de fichiers sur l'appareil, enregistrer sous

3) Sélectionnez Enregistrer sur « Périphérique MicroPython » :

Thonny IDE Enregistrer sur un périphérique MicroPython

4) Nommez votre fichier bh1750.py et appuyez sur le bouton OK :

enregistrer bh1750.py sur esp32 esp8266

Et c’est tout. La bibliothèque a été téléchargée sur votre tableau. Pour vous assurer qu’il a été téléchargé avec succès, accédez à Fichier > Enregistrer sous… et sélectionnez le périphérique MicroPython. Votre fichier devrait y être répertorié :

Fichier BH1750 enregistré sur les cartes ESP32 et ESP8266

Après avoir téléchargé la bibliothèque sur votre tableau, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

ESP32/ESP8266 – Luminance BH1750 (Lux) – Code

Après avoir téléchargé la bibliothèque, créez un nouveau fichier et collez le code suivant. Il lit la luminance en unités lux et imprime les lectures dans le Shell toutes les deux secondes.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-bh1750-esp32-esp8266/

from machine import Pin, SoftI2C
from bh1750 import BH1750
import time

# Initialize I2C communication (ESP32)
i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=400000)


# Initialize I2C communication (ESP8266)
#i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=400000)

# Create BH1750 object
light_sensor = BH1750(bus=i2c, addr=0x23)

try:
    # Read lux every 2 seconds
    while True:
        lux = light_sensor.luminance(BH1750.CONT_HIRES_1)
        print("Luminance: {:.2f} lux".format(lux))
        time.sleep(2)

except Exception as e:
    # Handle any exceptions during sensor reading
    print("An error occurred:", e)

Afficher le code brut

Comment fonctionne le code

Nous devons importer les classes Pin et SoftI2C depuis le module machine.

from machine import Pin, SoftI2C
from bh1750 import BH1750
import time

Dans ce cas, cette bibliothèque a besoin de SoftI2C au lieu d’I2C. Dans MicroPython, SoftI2C fait référence au logiciel I2C et I2C fait référence au matériel I2C.

Matériel I2C repose sur des modules matériels dédiés optimisés pour la communication I2C. L’I2C logiciel, quant à lui, utilise des broches GPIO définies par logiciel pour émuler la communication I2C.

On initialise une communication I2C sur les GPIO 21 et 22 sur l’ESP32, ou les GPIO 4 et 5 sur l’ESP8266. Assurez-vous de décommenter les broches de la carte que vous utilisez.

# Initialize I2C communication (ESP32)
#i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=400000)

# Initialize I2C communication (ESP8266)
i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=400000)

Créez ensuite une instance BH1750, appelée light_sensor sur le bus I2C défini précédemment. Nous utilisons l’adresse I2C 0x23. Si vous avez une adresse différente, modifiez-la sur la ligne suivante.

light_sensor = BH1750(bus=i2c, addr=0x23)

Pour obtenir les valeurs de luminance, il suffit d’utiliser la méthode luminance() sur l’objet BH1750 et de passer un mode de mesure en argument.

lux = light_sensor.luminance(BH1750.CONT_HIRES_1)

La bibliothèque fournit une liste de modes de mesure que vous pouvez utiliser. Voir le tableau ci-dessous.

Constante Description
CONT_LOWRES Continu, basse résolution (4lx), l’échantillonnage dure environ 24 ms, le capteur reste allumé après la lecture.
CONT_HIRES_1 Continu, haute résolution (1 lx), l’échantillonnage dure environ 180 ms, le capteur reste allumé après la lecture.
CONT_HIRES_2 Continu, très haute résolution (0,5 lx), l’échantillonnage dure environ 180 ms, le capteur reste allumé après la lecture.
ONCE_HIRES_1 One-shot, basse résolution (4lx), l’échantillonnage dure environ 24 ms, le capteur est éteint après la lecture
ONCE_HIRES_2 One-shot, haute résolution (1lx), l’échantillonnage dure environ 180 ms, capteur éteint après la lecture
ONCE_LOWRES One-shot, très haute résolution (.5lx), l’échantillonnage dure environ 180 ms, le capteur est éteint après la lecture

Enfin, nous imprimons les lectures dans le shell :

print("Luminance: {:.2f} lux".format(lux))

Tester le code

Exécutez le code précédent sur votre carte ESP32 ou ESP8266.

Test du script de code Thonny IDE

Vous devriez obtenir de nouvelles valeurs de luminance en unités lux toutes les deux secondes.

BH1750 obtient les valeurs de luminance sur Thonny IDE ESP32 et ESP8266

Couvrez le capteur ou dirigez un peu de lumière pour voir les valeurs changer.

ESP32 avec capteur de lumière ambiante BH1750

Conclusion

Dans ce didacticiel, nous avons expliqué comment utiliser le capteur de lumière ambiante BH1750 avec les cartes ESP32 et ESP8266 programmées avec MicroPython.

Le capteur BH1750 peut être utile dans un large éventail de projets pour détecter s’il fait jour ou nuit, régler la luminosité d’une LED en fonction de la lumière ambiante, détecter si une LED est allumée, et bien plus encore.

Nous espérons que vous avez trouvé ce tutoriel utile.

Nous avons des tutoriels pour d’autres capteurs avec ESP32/ESP8266 utilisant MicroPython qui pourraient vous plaire :

Apprenez-en davantage sur MicroPython grâce à nos ressources :

Merci d’avoir lu.

Plongez dans l’histoire de Raspberry Pi avec cette vidéo :

YouTube video