Allumer une lampe connectée à la carte ESP32 via Bluetooth

ESP32 24-11-23

516 0

Plan du tutoriel

1- Pourquoi on utilise App Inventor pour créer une application mobile capable de communiquer le smartphone avec la carte ESP32 ?

2- Les composants nécessaires pour contrôler une lampe par la carte ESP32

3- Montage de la carte ESP32 avec une lampe, le relais et le module HC-06

4- Programmer la carte ESP32 pour allumer une lampe par un smartphone via Bluetooth en utilisant Micrpython et MIT app Inventor

Pourquoi on utilise App Inventor pour créer une application mobile capable de communiquer le smartphone avec la carte ESP32 ?

App Inventor est souvent utilisé pour créer des applications mobiles en raison de sa facilité d'utilisation et de sa convivialité, notamment pour les débutants en programmation ou pour ceux qui veulent rapidement développer des applications sans avoir une expertise approfondie en codage. Lorsqu'il s'agit de communiquer avec des périphériques comme la carte ESP32, plusieurs raisons motivent ce choix :

Interface graphique conviviale : App Inventor offre une interface visuelle conviviale basée sur le glisser-déposer, permettant de créer des applications en assemblant des blocs de code sans nécessiter une connaissance approfondie en programmation.

Connectivité simplifiée : Pour établir une communication entre un smartphone et des appareils externes comme l'ESP32, App Inventor propose des composants prêts à l'emploi pour la communication Bluetooth et Wi-Fi, facilitant ainsi la connexion et la transmission de données.

Rapidité de développement : En utilisant App Inventor, il est possible de créer des prototypes d'applications rapidement, ce qui est particulièrement avantageux pour des projets où la rapidité de développement est cruciale.

Écosystème d'apprentissage : App Inventor est souvent utilisé dans des environnements éducatifs pour enseigner les bases de la programmation et encourager l'apprentissage de la logique de programmation sans la complexité du code traditionnel.

Documentation et support : Étant une plateforme populaire, App Inventor dispose d'une documentation abondante et d'une communauté active, offrant des ressources utiles et un support pour résoudre les problèmes rencontrés lors du développement.

En combinant la facilité de création d'applications mobiles avec des capacités de communication, App Inventor devient un choix attrayant pour ceux qui souhaitent créer des applications qui interagissent avec des dispositifs externes tels que l'ESP32.

Les composants nécessaires pour contrôler une lampe par la carte ESP32

Pour contrôler une lampe avec la carte ESP32, vous aurez besoin des composants suivants :

Carte ESP32 :

Carte ESP32

La carte ESP32 est une carte de développement basée sur le microcontrôleur ESP32, qui offre des fonctionnalités WiFi et Bluetooth intégrées. Vous pouvez utiliser cette carte pour programmer et contrôler une lampe à travers le relais.

Relais :

Un relais est un dispositif électromagnétique qui permet de contrôler des circuits électriques à haute puissance avec un circuit à faible puissance.

On va utiliser le relais pour isoler la faible tension de la carte ESP32 de la haute tension de la lampe. Assurez-vous que le relais que vous choisissez est compatible avec la carte ESP32 et peut gérer la tension et le courant requis pour votre lampe.

Lampe :

La lampe que vous souhaitez contrôler. Assurez-vous qu'elle est compatible avec le relais en termes de tension et de courant.

Source d'alimentation :

Vous aurez besoin d'une source d'alimentation pour la lampe, généralement une alimentation secteur de 220V pour les lampes de 220V. Assurez-vous que cette alimentation est adaptée à la lampe que vous utilisez.

Câblage électrique :

Vous aurez besoin de câbles électriques pour connecter la lampe, le relais, et la source d'alimentation. Assurez-vous que le câblage est correctement dimensionné et conforme aux normes de sécurité électrique.

Plaque d'essai (Breadboard) :

plaque d'essai

Une plaque d'essai est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

Fils de connexion :

Fils de connexion

Des fils de connexion sont nécessaires pour relier les différents composants ensemble, tels que la connexion entre la carte ESP32 et la relais.

Une fois que vous avez ces composants, vous pouvez commander la lampe par la carte ESP32 en utilisant le relais approprié.

Montage de la carte ESP32 avec une lampe et un relais

Pour monter une carte ESP32 avec une lampe, vous aurez besoin d'un relais pour isoler la basse tension de la carte ESP32 de la haute tension de la lampe. Voici un guide étape par étape pour réaliser ce montage en toute sécurité :

1- Assurez-vous que la lampe est déconnectée de toute alimentation électrique (débranchez-la de la prise secteur) avant de commencer le montage.

2- Connectez le relais à la carte ESP32 :

- Connecter la broche (-) du relais à la broche GND de la carte ESP32

- Connecter la broche (+) du relais à la broche 3.3V de la carte ESP32

- Connecter la broche (S) du relais à la broche numérique N°23 de la carte ESP32

3- Connectez la source d'alimentation de la lampe (220V) au relais :

- Connectez la phase de la lampe à la borne normalement ouverte (NO) du relais.

- Connectez la phase de la source d'alimentation à la borne commune (COM) du relais.

4- Assurez-vous que toutes les connexions sont sécurisées et que les fils ne sont pas exposés.

5- Une fois que tout est correctement câblé, branchez la lampe à une source d'alimentation secteur.

6- Testez votre montage en utilisant la carte ESP32 pour activer et désactiver la lampe via le relais.

Montage de la carte ESP32 avec une lampe et un relais

Programmer la carte ESP32 pour allumer une lampe par un smartphone via Bluetooth en utilisant Micrpython et MIT app Inventor

Pour allumer une lampe connectée à la carte ESP32 à l'aide de MicroPython et MIT App Inventor via Bluetooth, voici les étapes générales que vous devez suivre :

Côté ESP32 (MicroPython) :

1- Flasher le MicroPython sur l'ESP32 : Assurez-vous que vous avez installé MicroPython sur votre ESP32. Vous pouvez utiliser l'outil "esptool" pour flasher le firmware MicroPython sur la carte.

2- Établir la connexion Bluetooth : Utilisez les bibliothèques MicroPython pour activer le Bluetooth et le configurer pour qu'il agisse en tant que périphérique BLE (Bluetooth Low Energy).

3- Gérer les commandes Bluetooth : Écoutez les commandes Bluetooth provenant de l'application mobile. Lorsque vous recevez une commande pour allumer ou éteindre la lampe, contrôlez la broche du relais connecté à la lampe en conséquence.

Voici un exemple minimaliste de code MicroPython pour ce scénario (assurez-vous d'adapter cela à votre environnement) :

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.

########## 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
relay_pin=Pin(23, Pin.OUT) # Configuration du relais qui controle la lampe
 
# Create BLE object
ble = bluetooth.BLE() # Configuration Bluetooth
# 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): 
       relay_pin.value(1) # allumer la lampe
    if (uart_in.decode().find('0')==0): 
       relay_pin.value(0) # eteindre la lampe
# 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

relay_pin=Pin(23, Pin.OUT) # Configuration du relais qui controle la lampe

# Create BLE object

ble = bluetooth.BLE() # Configuration Bluetooth

# 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):

relay_pin.value(1) # allumer la lampe

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

relay_pin.value(0) # eteindre la lampe

# Map ISR to UART read interrupt

uart.irq(handler=on_rx)

uart.close()

Côté App Inventor :

1- Créez une nouvelle application sur MIT App Inventor.

2- Utilisez les composants Bluetooth du designer pour configurer la communication avec l'ESP32.

extensions_bluetooth

- L'extension "BluetoothLE1" fait en effet référence à une extension spécifique pour MIT App Inventor qui permet de gérer la communication Bluetooth Low Energy (BLE) dans vos applications mobiles. Cette extension facilite l'interaction entre votre application App Inventor et les périphériques BLE, tels que les capteurs, les appareils de suivi, les dispositifs portables, etc.

- L'extension "BluetoothClient1" dans MIT App Inventor vous permet de créer des applications mobiles qui peuvent se connecter à des dispositifs Bluetooth, comme des modules Bluetooth série (par exemple, HC-06) connectés à des microcontrôleurs, des appareils Bluetooth audio, etc. Cette extension facilite la communication avec ces dispositifs en utilisant des connexions Bluetooth série.

3- À partir d'Android 12, les autorisations Bluetooth ont été renforcées pour améliorer la sécurité et la protection des données des utilisateurs. C'est pour cela on doit déclarer les autorisations dont votre application a besoin dans le fichier AndroidManifest.xml. Pour Bluetooth, vous devrez inclure les autorisations ACCESS_FINE_LOCATION, BLUETOOTH_SCAN, et éventuellement BLUETOOTH_CONNECT, en fonction des fonctionnalités que vous utilisez.

4- Utilisez ces blocs de programmation pour connecter le smartphone à la carte ESP32 via Bluetooth

5- Ajoutez un bouton pour allumer la lampe dans la partie Designer.

6- Ajoutez un bouton pour éteindre la lampe dans la partie Designer.

7- Utilisez les blocs de programmation pour envoyer des commandes Bluetooth à l'ESP32 lorsque le bouton est cliqué.

Voici un exemple complet de ce à quoi cela pourrait ressembler dans App Inventor :

Partie designer de l'application mobile

Partie programme de l'application mobile

Télécharger le projet aia Télécharger le fichier apk

Assurez-vous d'utiliser les UUID appropriés pour les services et les caractéristiques Bluetooth, ainsi que de gérer les commandes et les réponses en conséquence dans votre code MicroPython et dans App Inventor.