ESP32

Construction des objets connectés basés sur la carte ESP32

05-11-22 2984

Ce module est particulièrement ambitieux car chaque élève va réaliser son propre objet connecté.

Définition des objets connectés :

Les objets connectés sont des objets dotés de capteurs capables de communiquer des données à un ordinateur, une tablette et un Smartphone via Wifi ou Bluetooth.

L’objet connecté collecte des données (températures par exemple) provenant de son environnement.
L’objet connecté transmet les données à un ordinateur, une tablette ou un Smartphone via Wifi ou Bluetooth.
objet connecté permet d’enclencher une action souvent grâce à une application (par exemple allumer une lampe par le Smartphone).

Définition de l’Internet des objets :

L’internet des objets (IOT: Internet on Things) est la connexion des objets physiques à l’Internet.

Les objets physiques désignent des appareils de la vie quotidienne comme les capteurs, des machines agricoles et des robots industriels

L’objet connecté à l’Internet des objets collecte des données sur son environnement via des capteurs. Il les envoie ensuite à un ordinateur, Smartphone ou tablette à l’aide d’une carte électronique équipée d’un module WIFI

Exemples d’objets connectés :

La montre connectée:

Elle permet de personnaliser l’affichage de l’heure, de mesurer votre activité physique, de lire et répondre à vos SMS et e-mails, de gérer vos contacts, de consulter la météo, de régler des alarmes et bien plus.

Thermomètre connecté :

Au sens large un objet connecté est un objet capable d’envoyer des informations à un autre périphérique. Autrement présentés comme des thermomètres sans fil ou thermomètre Bluetooth.

Les lampes connectées :

L’avantage ou plutôt la valeur ajoutée des lampes connectées au domaine de l’éclairage connecté, se trouve au niveau de leurs fonctionnalités.

De plus, elles sont connectées en bluetooth ou wi-fi à votre smartphone ce qui vous permet de programmer un des réveils personnalisés pour chaque jour de la semaine. Les applications permettent également la mise en veille ou la mises en route des ampoules connectées. Certaines ont également la capacité de l’allumer dès que vous rentrez chez vous, à condition bien évidemment d’avoir votre smartphone sur vous.

Les ampoules connectées qui changent de couleurs selon vos envies, ont une variété de couleurs différentes pouvant excéder un million.

Vous pouvez également en régler l’intensité. De quoi ne jamais voir la vie sous la même lumière.

Créer un objet connecté basé sur ESP32 :

La carte ESP32 est équipée de Bluetooth et WIFI pour communiquer avec les Smartphones et les ordinateurs.

Divers capteurs peuvent être connectés sur la carte ESP32 afin de rendre l’objet connecté.

Fabriquer un objet connecté comportant un capteur de température et de l’humidité communicant via Bluetooth :

Dans ce projet, nous allons apprendre comment réaliser un objet connecté à l’aide de la carte ESP32.

On collectera à intervalle régulier la température et l’humidité du capteur DHT11.

Les données seront envoyées via Bluetooth à l’application mobile du Smartphone.

C’est pour cela, on va créer deux programmes: une application mobile avec App Inventor pour le Smartphone et un programme micropython pour la carte EPS32.

Composants nécessaires

carte ESP32

ESP32 est une carte de développement électronique basée sur le microcontrôleur ESP32 de la société Espressif. Il s’agit d’un microcontrôleur à double cœur avec un processeur principal Xtensa LX6 et un processeur secondaire dedié au traitement du signal. La carte ESP32 est conçue pour être utilisée dans les applications IoT (Internet des objets) et comprend une variété de fonctionnalités pour faciliter la communication avec d’autres dispositifs et l’accès à Internet.

Voici quelques-unes des principales caractéristiques de la carte ESP32 :

Bluetooth et WiFi : La carte ESP32 inclut un module WiFi et Bluetooth pour faciliter la communication sans fil avec d’autres dispositifs.
Connectivité : La carte ESP32 est équipée de plusieurs ports de communication, tels que USB, UART, I2C et SPI, ce qui la rend idéale pour la communication avec d’autres composants électroniques.
Mémoire : La carte ESP32 dispose de 512 Ko de mémoire flash et de 8 Mo de RAM.
Energie : La carte ESP32 est alimentée par une tension de 3,3 V et est dotée d’un circuit de gestion de l’alimentation pour gérer les périodes de veille et d’arrêt.
Logiciels : La carte ESP32 est compatible avec un large éventail de logiciels de développement, tels que Arduino, ESP-IDF et MicroPython. Cela permet aux développeurs de choisir le logiciel de développement qui leur convient le mieux.

plaque d’essai

Une plaque d’essai est un type de carte de développement électronique qui permet aux développeurs de tester et de prototyper facilement des circuits électroniques. Elles sont souvent utilisées par les développeurs pour tester rapidement des idées et des conceptions avant de les intégrer à un projet plus important ou de les intégrer dans une carte de développement plus permanente.

Les plaques d’essai sont généralement basées sur un microcontrôleur, qui est un processeur facile à utiliser et à programmer qui peut être utilisé pour contrôler une variété de circuits électroniques. Les plaques d’essai incluent généralement des broches d’extension qui permettent de connecter facilement des composants électroniques tels que des capteurs, des afficheurs, des moteurs et d’autres composants.

capteur DHT11

Le capteur DHT11 est un capteur de température et d’humidité relative qui peut être utilisé dans une variété de projets électroniques. Il est relativement bon marché et facile à utiliser, ce qui en fait un choix populaire pour les projets de débutants.

Le capteur DHT11 est constitué d’un boîtier en plastique qui contient un microprocesseur et un capteur de température et d’humidité. Il est généralement connecté à une carte de développement telle qu’une plaque d’essai Arduino ou un Raspberry Pi via un câble de données. Le capteur DHT11 peut être configuré pour envoyer des données de température et d’humidité relative à un processeur toutes les secondes ou toutes les minutes, selon les besoins du projet.

Le capteur DHT11 est particulièrement utile dans les projets de monitoring de l’environnement, tels que les systèmes de contrôle de l’humidité dans les serres ou les systèmes de surveillance de la qualité de l’air. Il peut également être utilisé dans les projets de domotique, comme les thermostats intelligents.

des fils de connexion

Les fils de connexion sont des fils électriques utilisés pour connecter des composants électroniques à une carte de développement ESP32. Ils sont généralement utilisés pour connecter des capteurs, des actionneurs, des afficheurs et d’autres composants à la carte ESP32 afin de créer des circuits électroniques.

Il existe deux types de fils de connexion: les fils de connexion mâle-mâle et les fils de connexion mâle-femelle. Les fils de connexion mâle-mâle sont utilisés pour connecter des composants qui ont tous deux des broches mâles, tandis que les fils de connexion mâle-femelle sont utilisés pour connecter des composants avec une broche mâle et une broche femelle.

Les fils de connexion sont généralement fabriqués en cuivre ou en alliage de cuivre et sont revêtus d’un isolant en plastique pour protéger les fils électriques et empêcher les courts-circuits. Ils sont disponibles dans une variété de couleurs pour aider à identifier et organiser les différents fils dans un circuit.

Montage

Pour réaliser le montage il faut connecter:

la broche GND du capteur DHT11 à la broche GND de la carte ESP32
la broche DATA du capteur DHT11 à la broche GPIO23 de la carte ESP32
la broche VCC du capteur DHT11 à la broche 3.3V de la carte ESP32

Programme micropython:

Voici le programme micropython qui permet de :

– mesurer la température et l’humidité grâce au capteur DHT11

– connecter la carte ESP32 au smartphone via Bluetooth

– envoyer périodiquement la température et l’humidité

########## DIGITAL MANUFACTURING ##########
# PIKACHU Project
# Authors: Miguel Angel Guzman
#          Kadriye Nur Bakirci
###########################################

########## IMPORT REQUIRED LIBRARIES ##########

import bluetooth
from ble_uart_peripheral import BLEUART
from machine import Pin
import dht
import time
p23=Pin(23, Pin.IN)# lier la carte ESP32 au capteur DHT11 
d=dht.DHT11(p23)

# Create BLE object
ble = bluetooth.BLE()
# Open UART session for BLE
uart = BLEUART(ble)
# Define ISR for an UART input on BLE connection
def on_rx():
    # Read UART string, AppInventor sends raw bytes
    uart_in = uart.read() # lire le message recu du Smartphone via Bluetooth
    print("UART IN: ", uart_in.decode()) # afficher le message recu du Smartphone sur le console de Thonny
# Map ISR to UART read interrupt
def env_tx(val_tx):
    uart.write(str(val_tx) + '\n')
    print("tx", val_tx)
# Map ISR to UART read interrupt
uart.irq(handler=on_rx)
while True:
    d.measure() #Measurement of temperature and Humidity
    t=d.temperature() #lire la temperature
    h=d.humidity() # lire l'humidity
    print('Temperature=', t, 'C')
    print('Humidity=', h)
    message=str(t)+" °C"
    env_tx(message) # envoi la température au Smartphone 
    message=str(h)+" %"
    env_tx(message) # envoi l'humdity au Smartphone
    time.sleep_ms(2000)
uart.close()

########## DIGITAL MANUFACTURING ##########

# PIKACHU Project

# Authors: Miguel Angel Guzman

# Kadriye Nur Bakirci

###########################################

########## IMPORT REQUIRED LIBRARIES ##########

import bluetooth

from ble_uart_peripheral import BLEUART

from machine import Pin

import dht

import time

p23=Pin(23, Pin.IN)# lier la carte ESP32 au capteur DHT11

d=dht.DHT11(p23)

# Create BLE object

ble = bluetooth.BLE()

# Open UART session for BLE

uart = BLEUART(ble)

# Define ISR for an UART input on BLE connection

def on_rx():

# Read UART string, AppInventor sends raw bytes

uart_in = uart.read() # lire le message recu du Smartphone via Bluetooth

print("UART IN: ", uart_in.decode()) # afficher le message recu du Smartphone sur le console de Thonny

# Map ISR to UART read interrupt

def env_tx(val_tx):

uart.write(str(val_tx) + '\n')

print("tx", val_tx)

# Map ISR to UART read interrupt

uart.irq(handler=on_rx)

while True:

d.measure() #Measurement of temperature and Humidity

t=d.temperature() #lire la temperature

h=d.humidity() # lire l'humidity

print('Temperature=', t, 'C')

print('Humidity=', h)

message=str(t)+" °C"

env_tx(message) # envoi la température au Smartphone

message=str(h)+" %"

env_tx(message) # envoi l'humdity au Smartphone

time.sleep_ms(2000)

uart.close()

– Il faut importer ces bibliothèques :ble_uart_peripheral.py et ble_advertising.py.

– il faut utiliser le Firmware suivant : esp32-20210902-v1.17.bin

Création de l’application avec AppInventor:

On va créer une application mobile nommée ‘esp32_temperature_humidity’ avec App Inventor qui permet de connecter le smartphone à la carte ESP32 et de recevoir périodiquement la température et l’humidité mesuré par le capteur DTH11.

On vous propose donc de réaliser le design de l’application, avec le visuel suivant

Programmation avec App Inventor

Pour programmer l’application, App Inventor nous propose d’utiliser L’espace Blocs qui permet de créer un programme sous forme de schéma bloc. Très simple d’utilisation mais nécessitant un peu de logique de programmation.

Voici le programme de l’application réalisée dans l’espace Blocs de l’App Inventor:

Remarque:

Après avoir installer l’application mobile sur votre Smartphone, il faut suivre ces étapes pour se connecter à la carte ESP32 il faut :

Cliquer sur le bouton ‘scan‘
Après avoir trouvé la carte Micro:bit, Cliquer sur le bouton ‘Stop‘
Appuyer sur le nom de la carte ESP32
Enfin Cliquer sur le bouton ‘connect‘

Télécharger le projet https://www.robotique.tech/wp-content/uploads/2022/11/esp32_temperature_humidity.apk

Fabriquer une lampe connectée avec la carte ESP32:

Dans ce projet, on va réaliser une lampe capable d’être allumée par le smartphone via Bluettooh.

C’est pour cela, on va créer deux programmes: une application mobile avec App Inventor pour le smartphone et un programme makecode pour la carte ESP32.

Composants nécessaires

carte ESP32

plaque d’essai

Une plaque d’essai est un type de carte de développement électronique qui permet aux développeurs de tester et de prototyper facilement des circuits électroniques. Elles sont souvent utilisées par les développeurs pour tester rapidement des idées et des conceptions avant de les intégrer à un projet plus important ou de les intégrer dans une carte de développement plus permanente.

Les plaques d’essai sont généralement basées sur un microcontrôleur, qui est un processeur facile à utiliser et à programmer qui peut être utilisé pour contrôler une variété de circuits électroniques. Les plaques d’essai incluent généralement des broches d’extension qui permettent de connecter facilement des composants électroniques tels que des capteurs, des afficheurs, des moteurs et d’autres composants.

relais

Un relais est un interrupteur électrique qui est utilisé pour mettre un circuit sous ou hors tension. Il est souvent utilisé pour contrôler un circuit à haute puissance avec un signal à faible puissance, comme un interrupteur ou un signal de commande informatique. Les relais sont utilisés dans une grande variété d’applications, notamment les systèmes de commande industrielle. Ils peuvent être utilisés pour contrôler des moteurs, des lumières et d’autres charges électriques. Certains relais sont conçus pour commuter rapidement un circuit sous et hors tension, tandis que d’autres sont conçus pour un contrôle plus précis et peuvent être utilisés pour moduler le courant qui traverse un circuit.

une lampe ordinaire de 220V

des fils de connexion

Les fils de connexion sont des fils électriques utilisés pour connecter des composants électroniques à une carte de développement ESP32. Ils sont généralement utilisés pour connecter des capteurs, des actionneurs, des afficheurs et d’autres composants à la carte ESP32 afin de créer des circuits électroniques.

Il existe deux types de fils de connexion: les fils de connexion mâle-mâle et les fils de connexion mâle-femelle. Les fils de connexion mâle-mâle sont utilisés pour connecter des composants qui ont tous deux des broches mâles, tandis que les fils de connexion mâle-femelle sont utilisés pour connecter des composants avec une broche mâle et une broche femelle.

Les fils de connexion sont généralement fabriqués en cuivre ou en alliage de cuivre et sont revêtus d’un isolant en plastique pour protéger les fils électriques et empêcher les courts-circuits. Ils sont disponibles dans une variété de couleurs pour aider à identifier et organiser les différents fils dans un circuit.

Montage

Pour réaliser le montage il faut connecter:

la broche (-) du relais à la broche GND de la carte ESP32
la broche (+) du relais à la broche 3.3V de la carte ESP32
la broche (S) du relais à la broche GPIO23 de la carte ESP32
la broche (ON) du relais à l’un des bornes de la lampe
la broche (COM) du relais à la source électrique
l’autre borne de la lampe à la source électrique

Programme micropython

Voici le programme micropython qui permet de connecter la carte ESP32 au smartphone et de piloter à distance une ampoule :

– Si la carte ESP32 reçoit la valeur ‘1’ du Smartphone, elle allume la lampe.

– Si la carte ESP32 reçoit la valeur ‘0’ du Smartphone, elle éteint la lampe.

########## DIGITAL MANUFACTURING ##########
# PIKACHU Project
# Authors: Miguel Angel Guzman
#          Kadriye Nur Bakirci
###########################################

########## IMPORT REQUIRED LIBRARIES ##########

import bluetooth
from ble_uart_peripheral import BLEUART
from machine import Pin
lampe=Pin(23, Pin.OUT)

# Create BLE object
ble = bluetooth.BLE()
# Open UART session for BLE
uart = BLEUART(ble)
# Define ISR for an UART input on BLE connection
def on_rx():
    # Read UART string, AppInventor sends raw bytes
    uart_in = uart.read() # lire le message recu du Smartphone via Bluetooth
    print("UART IN: ", uart_in.decode()) # afficher le message recu du Smartphone sur le console de Thonny
    if (uart_in.decode().find('1')==0): 
       lampe.value(1) # allumer la lampe
    else :
       lampe.value(0) # éteidre LED
# Map ISR to UART read interrupt
uart.irq(handler=on_rx)
uart.close()

########## DIGITAL MANUFACTURING ##########

# PIKACHU Project

# Authors: Miguel Angel Guzman

# Kadriye Nur Bakirci

###########################################

########## IMPORT REQUIRED LIBRARIES ##########

import bluetooth

from ble_uart_peripheral import BLEUART

from machine import Pin

lampe=Pin(23, Pin.OUT)

# Create BLE object

ble = bluetooth.BLE()

# Open UART session for BLE

uart = BLEUART(ble)

# Define ISR for an UART input on BLE connection

def on_rx():

# Read UART string, AppInventor sends raw bytes

uart_in = uart.read() # lire le message recu du Smartphone via Bluetooth

print("UART IN: ", uart_in.decode()) # afficher le message recu du Smartphone sur le console de Thonny

if (uart_in.decode().find('1')==0):

lampe.value(1) # allumer la lampe

else :

lampe.value(0) # éteidre LED

# Map ISR to UART read interrupt

uart.irq(handler=on_rx)

uart.close()

– Il faut importer ces bibliothèques :ble_uart_peripheral.py et ble_advertising.py.

– il faut utiliser le Firmware suivant : esp32-20210902-v1.17.bin

Création de l’application avec AppInventor:

On va créer une application mobile nommée ‘esp32_allumer_lampe’ avec App Inventor qui permet de connecter le smartphone à la carte ESP32 et allumer à distance une lampe ordinaire.

On vous propose donc de réaliser le design de l’application, avec le visuel suivant

Programmation avec App Inventor

Voici le programme de l’application réalisée dans l’espace Blocs de l’App Inventor:

Remarque:

Après avoir installer l’application mobile sur votre Smartphone, il faut suivre ces étapes pour se connecter à la carte ESP32 il faut :

Cliquer sur le bouton ‘scan‘
Après avoir trouvé la carte Micro:bit, Cliquer sur le bouton ‘Stop‘
Appuyer sur le nom de la carte ESP32
Enfin Cliquer sur le bouton ‘connect‘

Télécharger le projet Télécharger l'application

Système de détection de flamme intelligent avec la carte ESP32 connecté à l’Internet:

Dans ce projet on va réaliser un système de détection incendie intelligent avec la carte ESP32 connecté au réseau Internet.

Il utilise principalement un capteur de flamme KY-026 et un buzzer.

Lorsque le capteur de flamme détecte une flamme, la carte ESP32 donne l’ordre au buzzer de sonner et envoie un email alerte par WIFI.

Composants nécessaires

une carte ESP32

un détecteur de flamme KY-026

Le détecteur de flamme KY-026 est un capteur qui est utilisé pour détecter la présence de flammes. Il est souvent utilisé dans les applications de sécurité incendie, comme les alarmes de fumée et les systèmes de détection de flammes.

Le KY-026 est un capteur à infrarouge qui utilise une diode emetteur-récepteur (IRED) pour détecter les rayonnements infrarouges émis par les flammes. Lorsqu’une flamme est détectée, le capteur envoie un signal à un dispositif de commande, comme un microcontrôleur ou un circuit de commande, pour indiquer que la flamme a été détectée.

Le KY-026 peut être utilisé avec un microcontrôleur, comme un Arduino, pour créer des systèmes de sécurité incendie automatisés ou pour détecter la présence de flammes dans d’autres applications. Il est important de noter que le KY-026 ne doit pas être utilisé pour remplacer un système de sécurité incendie professionnel ou un équipement de protection contre l’incendie. Il est recommandé de toujours suivre les règles de sécurité incendie appropriées et de se référer aux normes et aux codes locaux en matière de sécurité incendie.

un buzzer

Un buzzer est un dispositif électronique simple qui produit un bruit de bourdonnement ou de bip. Les buzzers sont souvent utilisés comme alarmes, minuteries ou pour indiquer qu’une action ou un événement a eu lieu. On peut les trouver dans une variété d’applications, notamment les appareils ménagers, les véhicules et les jouets électroniques.

Les buzzers se composent généralement d’un élément piézoélectrique, qui est un matériau qui génère une tension électrique lorsqu’il est déformé mécaniquement, et d’un circuit oscillateur. Lorsque l’élément piézoélectrique est déformé par le circuit oscillateur, il produit un son. La fréquence et le volume du son produit par un buzzer peuvent être contrôlés en ajustant le circuit oscillateur.

Les buzzers peuvent être activés en appliquant une tension sur leurs bornes d’entrée. Certains buzzers sont activés par une faible tension, tandis que d’autres nécessitent une tension plus élevée. Les buzzers sont généralement petits et peu coûteux, et ils sont faciles à utiliser dans une grande variété de projets électroniques.

des fils de connexion

une plaque d’essai

Montage

Pour réaliser le montage, on peut connecter

le borne (+) de buzzer à la broche D4 de la carte ESP32
le borne (-) de buzzer à la broche GND de la carte ESP32
la broche DO du capteur de flamme à la broche D34 de la carte ESP32
la broche VCC du capteur de flamme à la broche 3.3V de la carte ESP32
la broche GND du capteur de flamme à la broche GND de la carte ESP32

Programme en micropython

Voici le programme du système de détection incendie intelligent connecté à l’Internet:

Remarque: il faut importer les deux bibliothèques: ConnectWifi.py et umail.py.

print('RUN : main.py')
import ConnectWifi
import umail from machine
import Pin, ADC from time
import sleep

ConnectWifi.connect() #connecter au réseau Internet par wifi
flamme = ADC(Pin(34))
flamme.atten(ADC.ATTN_11DB) #Full range: 3.3v
buzzer=Pin(4,Pin.OUT)
while True:
  flamme_value = flamme.read() 
  sleep(0.1)
  if (flamme_value<4095): #détection d'une flamme
     buzzer.value(1) # le buzzer se met à sonner
     smtp = umail.SMTP('smtp.gmail.com', 587,       
     username='emetteur@gmail.com', password='******')
     smtp.to('recepteur@gmail.com') smtp.send("Alerte incendie") # Envoie d'un email alerte
     smtp.quit()
  else:
     buzzer.value(0) #le buzzer s'arrête de sonner

print('RUN : main.py')

import ConnectWifi

import umail from machine

import Pin, ADC from time

import sleep

ConnectWifi.connect() #connecter au réseau Internet par wifi

flamme = ADC(Pin(34))

flamme.atten(ADC.ATTN_11DB) #Full range: 3.3v

buzzer=Pin(4,Pin.OUT)

while True:

flamme_value = flamme.read()

sleep(0.1)

if (flamme_value<4095): #détection d'une flamme

buzzer.value(1) # le buzzer se met à sonner

smtp = umail.SMTP('smtp.gmail.com', 587,

username='emetteur@gmail.com', password='******')

smtp.to('recepteur@gmail.com') smtp.send("Alerte incendie") # Envoie d'un email alerte

smtp.quit()

else:

buzzer.value(0) #le buzzer s'arrête de sonner

Utilisation de l’Internet des objets dans l’Agriculture avec la carte ESP32

Ce projet décrit l’application d’IoT (Internet des Objets) dans l’agriculture. Dans ce milieu on prend les mesures l’humidité du sol d’une plante.
La surveillance du paramètre autour de ce processus (informations fournies par le capteur du sol) est effectuée à l’aide des outils et ressources open source tels que ESP32 et ThingSpeak.
On a fait lecture des données du capteur en temps réel sur internet à travers une page web et aussi sur les graphes dans ThingSpeak.

Ce travail est effectué à l’aide d’un microcontrôleur ESP32 qui permettra d’envoyer toutes les informations par WIFI concernant l’environnement de notre plante, vers ThingSpeak.

Composants nécessaires

une carte ESP32

un capteur de l’humidité du sol

Un capteur d’humidité du sol mesure le taux d’humidité dans le sol. Cela peut être utile pour surveiller les conditions de culture d’une plante ou pour contrôler l’arrosage d’un jardin ou d’une pelouse. Les capteurs d’humidité du sol sont généralement utilisés dans les systèmes de contrôle de l’irrigation, les stations météorologiques et les systèmes de gestion des cultures. Ils peuvent être utilisés à l’intérieur ou à l’extérieur et peuvent être connectés à un système de contrôle pour fournir des données en temps réel sur l’humidité du sol. Il existe différents types de capteurs d’humidité du sol, y compris ceux qui utilisent une résistance électrique, une capacité électrique ou une conductivité électrique pour mesurer l’humidité.

des fils de connexion

une plaque d’essai

Montage

Pour réaliser le montage, on peut connecter:

pour le capteur du sol :

la broche S à la broche D34 de la carte ESP32
la broche (+) à la broche 3.3V de la carte ESP32
la broche (-) à la broche GND de la carte ESP32

Les valeurs de l'humidité du sol envoyées par la carte ESP32 au site thinkspeak.com

Programme en micropython

from simple import MQTTClient
import network
import time 
from time import sleep
from machine import Pin,ADC
import dht
WiFi_SSID = "HUAWEI Y5 2019"
WiFi_PASS = "b582058c4d86"

SERVER = "mqtt.thingspeak.com"
client = MQTTClient("umqtt_client", SERVER)
CHANNEL_ID = "979420"
WRITE_API_KEY = "KM7MYIGX8G2X6GA0"

pin_sol = ADC(Pin(34))
pin_sol.atten(ADC.ATTN_11DB)

def do_connect():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('connecting to network...')
        wlan.connect(WiFi_SSID, WiFi_PASS)
        while not wlan.isconnected():
            pass
    print('network config:', wlan.ifconfig())

do_connect()
time.sleep(3)
topic = "channels/" + CHANNEL_ID + "/publish/" + WRITE_API_KEY

while True:
  humidite_value = pin_sol.read()
  payload = "field1="+str(humidite_value)
  client.connect()
  client.publish(topic, payload) # envoyer les valeurs de la temperature et l'humidite au site thingspeak.com
  client.disconnect()
  time.sleep(60)

from simple import MQTTClient

import network

import time

from time import sleep

from machine import Pin,ADC

import dht

WiFi_SSID = "HUAWEI Y5 2019"

WiFi_PASS = "b582058c4d86"

SERVER = "mqtt.thingspeak.com"

client = MQTTClient("umqtt_client", SERVER)

CHANNEL_ID = "979420"

WRITE_API_KEY = "KM7MYIGX8G2X6GA0"

pin_sol = ADC(Pin(34))

pin_sol.atten(ADC.ATTN_11DB)

def do_connect():

wlan = network.WLAN(network.STA_IF)

wlan.active(True)

if not wlan.isconnected():

print('connecting to network...')

wlan.connect(WiFi_SSID, WiFi_PASS)

while not wlan.isconnected():

pass

print('network config:', wlan.ifconfig())

do_connect()

time.sleep(3)

topic = "channels/" + CHANNEL_ID + "/publish/" + WRITE_API_KEY

while True:

humidite_value = pin_sol.read()

payload = "field1="+str(humidite_value)

client.connect()

client.publish(topic, payload) # envoyer les valeurs de la temperature et l'humidite au site thingspeak.com

client.disconnect()

time.sleep(60)

Remarque: il faut importer la bibliothèque suivante: simple.py

By Construction des objets connectés basés sur ESP32

La carte ESP32 est utilisé pour la construction d'objets connectés, c'est-à-dire d'appareils qui sont connectés à Internet et qui peuvent être contrôlés et surveillés à distance
Contenturl

Published:
Modified: