MicroPython : ESP32/ESP8266 avec anémomètre (capteur de vent)

MicroPython : ESP32/ESP8266 avec anémomètre (capteur de vent)

Dans ce guide, vous apprendrez à interfacer un anémomètre pour mesurer la vitesse du vent avec les cartes NodeMCU ESP32 et ESP8266 programmées avec MicroPython. Nous expliquerons comment alimenter et connecter le capteur aux cartes ESP32 et ESP8266, et écrireons un code simple pour obtenir les valeurs de vitesse du vent dans différentes unités.

MicroPython ESP32 ESP8266 NodeMCU avec capteur de vent anémomètre

Table des matières:

Tout au long de ce guide, nous aborderons les sujets suivants :

Nouveau sur MicroPython ? Consultez notre eBook : Programmation MicroPython avec ESP32 et ESP8266 eBook (2e édition)

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

Présentation de l’anémomètre

Un anémomètre est un appareil qui permet de mesurer la vitesse du vent. Il est couramment utilisé dans les stations météorologiques.

L’utilisation de ce capteur est assez simple. Il produit un signal analogique dont la tension est proportionnelle à la vitesse du vent. Nous utilisons un anémomètre à trois coupelles comme celui de l’image ci-dessous.

Anémomètre à capteur de vent

Détails techniques de l’anémomètre

Selon le fabricant, l’anémomètre peut avoir des caractéristiques différentes. Par exemple, voici les caractéristiques de l’anémomètre utilisé dans ce guide :

  • Tension d’entrée : 12-24 V CC.
  • Tension de sortie : 0-5 V
  • Plage de mesure : 0-32,4 m/s
  • Résolution : +/- 0,3 m/s

Cela signifie que lorsque le signal analogique est à 0, la vitesse du vent est à 0. Cependant, dans mon cas, après avoir alimenté le capteur et appliqué une tension régulière, j’ai remarqué que lorsque l’anémomètre ne bougeait pas, la tension de sortie était de 0,033V et non 0 V.

ESP32 Mesure la tension du capteur de vent sans vent

Je considère donc que c’est la valeur la plus basse mesurée lorsque le capteur ne bouge pas. Je vous recommande de faire de même et de déterminer la valeur minimale lue sur le capteur à l’aide d’un multimètre.

Ces détails peuvent être différents selon le fabricant. Vous devez donc en tenir compte lors de la conversion du signal analogique en vitesse du vent.

Brochage de l’anémomètre

L’anémomètre est livré avec trois fils :

Fil bleu Signal
Fil noir GND
Fil marron Pouvoir
Anémomètre, brochage du capteur de vent

Connexion de l’anémomètre à l’ESP32 et à l’ESP8266

L’anémomètre nécessite une tension d’entrée d’au moins 12 V. Vous ne pouvez donc pas l’alimenter directement depuis l’ESP32 ou l’ESP8266, vous avez besoin d’une source d’alimentation externe.

Adaptateur secteur 12 V CC

Nous alimentons le capteur à l’aide d’un adaptateur secteur 12 V et le connectons à l’anémomètre à l’aide d’une prise d’alimentation. Vous pouvez utiliser n’importe quelle autre source d’alimentation appropriée.

Adaptateur de prise d'alimentation CC

Conversion du signal de données de 5 V à 3,3 V

Dans le cas de mon capteur, il fonctionne dans la plage de 0 à 5V. Cependant, les broches analogiques ESP32 et ESP8266 ne peuvent lire qu’un maximum de 3,3 V. Nous devons donc convertir le signal 5V en un signal 3,3V. Pour ce faire, nous pouvons utiliser un diviseur de tension.

Remarque : si vous utilisez un anémomètre comme celui d’Adafruit, vous n’avez pas à vous en soucier car la tension de sortie maximale est de 2 V.

Un diviseur de tension est un circuit simple qui réduit une tension élevée en une tension plus petite. En utilisant 2 résistances et une tension d’entrée, nous pouvons créer une tension de sortie qui représente une fraction de l’entrée. Ci-dessous vous pouvez voir la formule que vous devez utiliser pour calculer les résistances dont vous avez besoin dans votre circuit :

formule du diviseur de tension

Si nous utilisons une résistance de 1 k Ohm (R1) et une résistance de 2 k Ohm (R2), nous obtiendrons une sortie maximale de 3,3 V, ce qui est le maximum que l’ESP32 peut lire.

Voici donc à quoi ressemble le circuit diviseur de tension (dans lequel 5 V est la valeur maximale de la broche de données du capteur) :

diviseur de tension 5V à 3,3V

Vous pouvez utiliser n’importe quelle autre combinaison de résistances, mais vous devez prendre en compte la tension de sortie maximale autorisée par la combinaison de résistances utilisée.

Apprenez-en plus ici : Comment passer de 5 V à 3,3 V

Câblage du circuit : ESP32 et ESP8266 avec anémomètre

ESP32 avec circuit anémomètre

Voici une liste des pièces dont vous avez besoin pour ce tutoriel :

Vous pouvez utiliser les schémas suivants comme référence pour câbler le capteur aux cartes. N’oubliez pas de connecter les broches GND ensemble.

ESP32

Pour l’ESP32, nous utilisons le GPIO34 pour lire le signal analogique du capteur, mais vous pouvez utiliser n’importe quel autre GPIO approprié pour la lecture analogique.

Schéma de circuit anémomètre ESP32 avec capteur de vent

ESP8266

L’ESP8266 n’a qu’une seule broche analogique, la broche A0. Vous devez donc utiliser cette broche pour lire le signal analogique du capteur.

ESP8266 avec schéma de circuit anémomètre à capteur de vent

Si vous utilisez un anémomètre comme celui d’Adafruit qui produit un maximum de 2 V, vous pouvez connecter la broche de sortie directement à la broche analogique ESP (vous n’avez pas besoin du diviseur de tension).

Fil noir GND de la carte ESP et GND de la source d’alimentation
Fil bleu Connectez-vous à la broche analogique ESP32/ESP8266 (via un diviseur de tension, si nécessaire), nous utilisons GPIO 34 pour l’ESP32 et A0 pour l’ESP8266.
Fil marron Alimentation 12 V (+)

ESP32 avec l’anémomètre – Mesurez la vitesse du vent Code MicroPython

Le code suivant lit le signal analogique de l’anémomètre et le convertit en vitesse du vent.

Vous pouvez télécharger le code suivant sur votre ESP32. Vous devrez peut-être modifier certaines variables en fonction des paramètres de votre anémomètre.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp32-esp8266-anemometer-wind-sensor/
 
from machine import ADC, Pin
from time import sleep

# Constants
# GPIO pin connected to anemometer (ESP32)
anemometer_pin = 34
min_voltage = 0.033  # Voltage corresponding to 0 m/s
max_voltage = 3.3    # Voltage corresponding to 32.4 m/s (max speed when using voltage divider)
max_wind_speed = 32.4 # Maximum wind speed in m/s

# Conversion factors
mps_to_kmh = 3.6     # 1 m/s = 3.6 km/h
mps_to_mph = 2.23694 # 1 m/s = 2.23694 mph

# Set up the ADC
adc = ADC(Pin(anemometer_pin))
adc.atten(ADC.ATTN_11DB)  # Configure ADC to read full 3.3V range (11dB attenuation)
adc.width(ADC.WIDTH_12BIT)  # Set resolution to 12 bits (0-4095)

while True:
    # Read analog value from anemometer (ADC value between 0-4095)
    adc_value = adc.read()
    
    # Convert ADC value to voltage
    voltage = (adc_value / 4095.0) * 3.3
    
    # Ensure the voltage is within the anemometer operating range
    if voltage < min_voltage:
        voltage = min_voltage
    elif voltage > max_voltage:
        voltage = max_voltage
    
    # Map the voltage to wind speed
    wind_speed_mps = ((voltage - min_voltage) / (max_voltage - min_voltage)) * max_wind_speed

    # Convert wind speed to km/h and mph
    wind_speed_kmh = wind_speed_mps * mps_to_kmh
    wind_speed_mph = wind_speed_mps * mps_to_mph

    # Print wind speed
    print("Wind Speed:")
    print("{:.2f} m/s".format(wind_speed_mps))
    print("{:.2f} km/h".format(wind_speed_kmh))
    print("{:.2f} mph".format(wind_speed_mph))
    print() 
    
    sleep(1)

Afficher le code brut

Le code de l’ESP8266 est légèrement différent : continuez à faire défiler le code MicroPython de l’ESP8266.

ESP8266 NodeMCU avec l’anémomètre – Mesurez la vitesse du vent Code MicroPython

Le code suivant fait exactement la même chose que le précédent, mais il a été adapté pour les cartes ESP8266 NodeMCU.

# Rui Santos & Sara Santos - Raspberryme.com
# Complete project details at https://Raspberryme.com/micropython-esp32-esp8266-anemometer-wind-sensor/
 
from machine import ADC, Pin
from time import sleep

# Constants
min_voltage = 0.033  # Voltage corresponding to 0 m/s
max_voltage = 3.3    # Voltage corresponding to 32.4 m/s (max speed when using voltage divider)
max_wind_speed = 32.4 # Maximum wind speed in m/s

# Conversion factors
mps_to_kmh = 3.6     # 1 m/s = 3.6 km/h
mps_to_mph = 2.23694 # 1 m/s = 2.23694 mph

# Set up the ADC
adc = ADC(0)

while True:
    # Read analog value from anemometer (ADC value between 0-1023)
    adc_value = adc.read()
    
    # Convert ADC value to voltage
    voltage = (adc_value / 1023.0) * 3.3
    
    # Ensure the voltage is within the anemometer operating range
    if voltage < min_voltage:
        voltage = min_voltage
    elif voltage > max_voltage:
        voltage = max_voltage
    
    # Map the voltage to wind speed
    wind_speed_mps = ((voltage - min_voltage) / (max_voltage - min_voltage)) * max_wind_speed

    # Convert wind speed to km/h and mph
    wind_speed_kmh = wind_speed_mps * mps_to_kmh
    wind_speed_mph = wind_speed_mps * mps_to_mph

    # Print wind speed
    print("Wind Speed:")
    print("{:.2f} m/s".format(wind_speed_mps))
    print("{:.2f} km/h".format(wind_speed_kmh))
    print("{:.2f} mph".format(wind_speed_mph))
    print() 
    
    sleep(1)

Afficher le code brut

Comment fonctionne le code ?

Nous commençons à importer les modules requis. Les classes ADC et Pin du module machine pour définir les GPIO comme broches ADC.

from machine import ADC, Pin
from time import sleep

Définissez la broche sur laquelle vous lisez le capteur, la tension de sortie minimale et maximale du capteur et la vitesse maximale du vent. Dans le cas de l’ESP32, nous utilisons le GPIO 34 pour lire le signal analogique du capteur de vent. 

# GPIO pin connected to anemometer (ESP32)
anemometer_pin = 34
min_voltage = 0.033  # Voltage corresponding to 0 m/s
max_voltage = 3.3    # Voltage corresponding to 32.4 m/s (max speed when using voltage divider)
max_wind_speed = 32.4 # Maximum wind speed in m/s

Dans le cas de l’ESP8266, la seule broche analogique disponible est A0. Nous devons donc le transmettre plus tard à l’objet ADC() comme ceci :

adc = ADC(0)

Ensuite, nous avons les facteurs de conversion pour convertir la vitesse du vent de m/s en km/h et mph.

# Conversion factors
mps_to_kmh = 3.6     # 1 m/s = 3.6 km/h
mps_to_mph = 2.23694 # 1 m/s = 2.23694 mph

Créez un objet ADC sur le GPIO que vous utilisez pour lire le capteur analogique. C’est comme ça pour l’ESP32 :

adc = ADC(Pin(anemometer_pin))

Et comme ça pour l’ESP8266 :

adc = ADC(0)

Lors de l’utilisation de l’ESP32. nous devons également transmettre les deux lignes suivantes.

adc.atten(ADC.ATTN_11DB)  # Configure ADC to read full 3.3V range (11dB attenuation)
adc.width(ADC.WIDTH_12BIT)  # Set resolution to 12 bits (0-4095)

La première ligne signifie que nous voulons lire une tension de 0 à 3,3 V. Cela correspond au réglage du taux d’atténuation de 11 dB.

La deuxième ligne de code définit la résolution sur 12 bits. Nous lirons donc un nombre compris entre 0 et 4095 sur la broche analogique.

Enfin, nous avons une boucle while qui obtient de nouvelles valeurs de vitesse du vent chaque seconde.

Tout d’abord, nous lisons la valeur sur la broche ADC et la convertissons en valeur de tension. La valeur maximale lue sur la broche ESP32 ADC est de 4095, ce qui correspond à 3,3 V. 

while True:
    # Read analog value from anemometer (ADC value between 0-4095)
    adc_value = adc.read()

Ainsi, nous pouvons convertir la valeur en tension en utilisant la ligne suivante :

# Convert ADC value to voltage
voltage = (adc_value / 4095.0) * 3.3

Ensuite, nous avons la condition suivante pour vérifier si les valeurs lues sont dans la plage définie.

# Ensure the voltage is within the anemometer operating range
if voltage < min_voltage:
    voltage = min_voltage
elif voltage > max_voltage:
    voltage = max_voltage

Ensuite, nous pouvons facilement mapper la tension obtenue à une valeur de vitesse du vent comme suit :

# Map the voltage to wind speed
wind_speed_mps = ((voltage - min_voltage) / (max_voltage - min_voltage)) * max_wind_speed

Ensuite, nous convertissons les valeurs obtenues en km/h et mph.

 # Convert wind speed to km/h and mph
 wind_speed_kmh = wind_speed_mps * mps_to_kmh
 wind_speed_mph = wind_speed_mps * mps_to_mph

Enfin, nous imprimons les résultats obtenus.

# Print wind speed
print("Wind Speed:")
print("{:.2f} m/s".format(wind_speed_mps))
print("{:.2f} km/h".format(wind_speed_kmh))
print("{:.2f} mph".format(wind_speed_mph))
print()

Démonstration

Exécutez ou téléchargez le code sur votre carte à l’aide de Thonny IDE.

Code d'exécution de l'IDE Thonny

Sur le MicroPython Shell, vous devriez obtenir des données sur la vitesse du vent.

Démonstration ESP32-ESP8266-Mesure-Vitesse-Vent-MucriPython

Vous devrez peut-être effectuer un étalonnage supplémentaire du capteur pour obtenir des résultats plus précis.

Conclusion

Dans ce didacticiel, vous avez appris à interfacer un anémomètre avec les cartes ESP32 et ESP8266 programmées avec MicroPython pour obtenir des données sur la vitesse du vent.

Nous espérons que vous avez trouvé ce guide rapide utile. Nous avons des guides pour d’autres capteurs et modules qui pourraient vous être utiles :

Pour en savoir plus sur MicroPython, consultez nos ressources :

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

YouTube video