Allumer deux lampes connectées à la carte ESP32 via Bluetooth

Bluetooth 28-11-23

322 0

Plan du tutoriel

Introduction

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 deux lampes par la carte ESP32

3- Montage de la carte ESP32 avec deux lampes, deux relais et le module HC-06

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

Introduction

Il est possible d'allumer une lampe à l'aide d'une carte ESP32 via Bluetooth ! La carte ESP32 est capable de se connecter à d'autres appareils via Bluetooth et peut contrôler des périphériques externes, comme une lampe, à l'aide de signaux ou de commandes envoyées via Bluetooth.

Pour réaliser cela, vous pouvez suivre ces étapes générales :

Connexion Bluetooth : Établissez une connexion entre la carte ESP32 et le périphérique de la lampe via Bluetooth. Cela implique l'appariement et l'échange de données entre les deux appareils.

Programmation : Utilisez un langage de programmation tel qu'Arduino ou MicroPython pour écrire un code qui permet à la carte ESP32 d'envoyer des commandes de contrôle à la lampe via la connexion Bluetooth. Vous devrez identifier le service et les caractéristiques nécessaires pour contrôler la lampe.

Contrôle de la lampe : Une fois que la connexion Bluetooth est établie et que le code est écrit, vous pourrez envoyer des commandes spécifiques à la lampe pour l'allumer, l'éteindre ou même ajuster son intensité lumineuse en fonction de la fonctionnalité prise en charge par la lampe et le protocole Bluetooth utilisé.

Tests et débogage : Testez votre code pour vous assurer que la communication entre l'ESP32 et la lampe fonctionne correctement. Assurez-vous que les commandes sont interprétées comme prévu et que la lampe répond comme attendu.

Si vous avez des informations spécifiques sur la lampe que vous souhaitez contrôler, comme le modèle de la lampe ou le protocole Bluetooth qu'elle utilise, cela pourrait aider à fournir des instructions plus précises pour réaliser cette tâche.

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 deux lampes par la carte ESP32

Pour contrôler deux lampes 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.

Deux 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.

Deux lampes :

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 deux lampes par la carte ESP32 en utilisant le relais approprié.

Montage de la carte ESP32 avec deux lampes et deux relais

Pour monter une carte ESP32 avec deux lampes, vous aurez besoin des 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 les deux lampes sont déconnectées de toute alimentation électrique (débranchez-la de la prise secteur) avant de commencer le montage.

2- Connectez le premier 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 première lampe (220V) au premier relais :

- Connectez la phase de la source d'alimentation à la borne normalement ouverte (NO) du relais.

- Connectez la phase de la première lampe à la borne commune (COM) du relais.

4- Connectez le deuxième 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°22 de la carte ESP32

5- Connectez la source d'alimentation de la deuxième lampe (220V) au deuxième relais :

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

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

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

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

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

Montage de la carte ESP32 avec deux lampes et deux relais

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

Pour allumer deux lampes connectées à 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 les deux broches de deux relais connectés aux deux lampes 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 et éteindre la première lampe dans la partie Designer.

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

7- Utilisez les blocs de programmation pour envoyer des commandes Bluetooth à l'ESP32 lorsque l'un des deux boutons 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.