Commander trois LEDs connectées à ESP32 via Bluetooth

Bluetooth 24-08-23

424 0

Plan du tutoriel

1- La carte ESP32 et le Bluetooth

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

3- Allumer trois LEDs connectées à la carte ESP32 par un smartphone via Bluetooth en utilisant le Micropython et MIT app Inventor

4- Les composants nécessaires pour contrôler trois LEDs par la carte ESP32

5- Montage de la carte ESP32 avec trois LEDs

La carte ESP32 et le Bluetooth

L'ESP32 est un microcontrôleur à faible coût et à faible consommation d'énergie qui intègre une connectivité Wi-Fi et Bluetooth. Il est largement utilisé pour une variété d'applications, allant de l'Internet des objets (IoT) aux projets électroniques et aux dispositifs embarqués. La présence du Bluetooth dans l'ESP32 lui permet de se connecter à d'autres appareils compatibles Bluetooth, comme des smartphones, des capteurs et d'autres périphériques.

Voici quelques points clés concernant l'ESP32 et sa fonctionnalité Bluetooth :

1- Double connectivité : L'ESP32 prend en charge à la fois le Bluetooth Classic et le Bluetooth Low Energy (BLE). Cela signifie qu'il peut se connecter à une large gamme d'appareils compatibles Bluetooth, offrant ainsi une grande flexibilité dans les applications.

2- Standalone ou coexistant avec Wi-Fi : L'ESP32 peut être utilisé pour des projets qui n'impliquent que le Bluetooth, ou il peut être configuré pour fonctionner simultanément en tant qu'émetteur/récepteur Wi-Fi et Bluetooth.

3- Profils Bluetooth : L'ESP32 peut être programmé pour implémenter différents profils Bluetooth, ce qui signifie qu'il peut agir en tant que serveur ou en tant que client. Par exemple, il peut agir en tant que serveur BLE pour exposer des services et des caractéristiques personnalisées aux appareils clients, ou en tant que client pour se connecter à d'autres appareils et récupérer des données.

4- Développement logiciel : Pour développer des applications Bluetooth avec l'ESP32, vous pouvez utiliser l'IDE Arduino avec le support ESP32, le framework ESP-IDF (IoT Development Framework) de Espressif, ou d'autres environnements de développement compatibles. Ces outils vous permettront de programmer le microcontrôleur pour gérer la communication Bluetooth et pour mettre en œuvre des fonctionnalités spécifiques.

5- Applications : L'ESP32 avec Bluetooth trouve des applications dans divers domaines, tels que la domotique (contrôle des appareils à partir d'un smartphone), le suivi d'activité (via des capteurs BLE), les systèmes de surveillance et de contrôle à distance, et bien d'autres.

6- Consommation d'énergie : Le BLE est conçu pour être économe en énergie, ce qui le rend idéal pour les applications alimentées par batterie. L'ESP32 intègre des fonctionnalités de gestion de l'énergie pour optimiser la durée de vie de la batterie dans les applications Bluetooth.

En résumé, l'ESP32 est un microcontrôleur polyvalent qui intègre la connectivité Bluetooth, ce qui lui permet de se connecter et de communiquer avec d'autres appareils compatibles Bluetooth. Cela ouvre la porte à une large gamme d'applications innovantes dans le domaine de l'électronique et de l'Internet des objets.

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

MIT App Inventor est une plateforme de développement d'applications mobiles conviviale qui permet aux personnes sans connaissances approfondies en programmation de créer des applications pour smartphones Android. Cette plateforme utilise une approche visuelle de la programmation, où les utilisateurs peuvent créer des applications en assemblant des blocs de fonctionnalités plutôt qu'en écrivant du code traditionnel.

Voici pourquoi MIT App Inventor est souvent utilisé pour créer des applications mobiles capables de communiquer avec la carte ESP32 :

1- Simplicité d'utilisation : MIT App Inventor est conçu pour être facile à apprendre et à utiliser, même pour ceux qui n'ont pas d'expérience en programmation. Cela en fait une option attrayante pour les débutants ou les personnes qui souhaitent créer des applications rapidement sans avoir à plonger dans des langages de programmation complexes.

2- Programmation visuelle : Au lieu d'écrire du code, les utilisateurs glissent-déposent des blocs de fonctionnalités graphiques pour créer la logique de leur application. Cela permet de créer rapidement des fonctionnalités comme la communication Bluetooth sans avoir à maîtriser les détails techniques du protocole.

3- Compatibilité Bluetooth : MIT App Inventor prend en charge la communication Bluetooth, ce qui permet de créer des applications qui peuvent interagir avec des appareils externes tels que l'ESP32 via Bluetooth. Les blocs de programmation liés au Bluetooth sont conçus pour faciliter la mise en place de connexions et d'interactions avec d'autres dispositifs.

4- Rapidité de développement : En utilisant MIT App Inventor, il est possible de créer rapidement un prototype fonctionnel d'application mobile pour interagir avec l'ESP32. Cela peut être très utile pour tester rapidement des idées, des concepts ou des projets.

5- Communauté et ressources : MIT App Inventor dispose d'une communauté active et de nombreuses ressources en ligne, notamment des tutoriels, des forums et des exemples de projets. Cela facilite l'apprentissage et la résolution des problèmes lors de la création de votre application.

6- Intégration matériel-logiciel : MIT App Inventor offre des blocs de programmation spécifiques pour la communication Bluetooth, ce qui facilite l'intégration entre le matériel (ESP32) et le logiciel (application mobile). Cela permet de créer des applications qui peuvent envoyer et recevoir des données avec l'ESP32 via Bluetooth.

En résumé, MIT App Inventor est utilisé pour créer des applications mobiles qui communiquent avec la carte ESP32 en raison de sa simplicité d'utilisation, de son approche visuelle de la programmation, de sa compatibilité Bluetooth et de sa rapidité de développement. Cela permet aux personnes sans compétences en programmation avancée de créer des applications interactives et fonctionnelles pour leurs projets impliquant l'ESP32.

Allumer trois LEDs connectées à la carte ESP32 par un smartphone via Bluetooth en utilisant le Micropython et MIT app Inventor

Pour allumer trois LEDs 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). Configurez un service et une caractéristique personnalisés pour contrôler les trois LEDs.

3- Gérer les commandes Bluetooth : Écoutez les commandes Bluetooth provenant de l'application mobile. Lorsque vous recevez une commande pour allumer ou éteindre trois LEDs, contrôlez la broche des trois LEDs 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
red_led=Pin(23, Pin.OUT) # Configuration de la LED rouge
green_led=Pin(22, Pin.OUT) # Configuration de la LED verte
yellow_led=Pin(21, Pin.OUT) # Configuration de la LED jaune 

# 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('red_on')==0): 
       red_led.value(1) # allumer la LED rouge
    if (uart_in.decode().find('red_off')==0): 
       red_led.value(0) # eteindre la LED rouge
    if (uart_in.decode().find('green_on')==0): 
       green_led.value(1) # allumer la LED verte 
    if (uart_in.decode().find('green_off')==0): 
       green_led.value(0) # eteindre la LED verte 
    if (uart_in.decode().find('yellow_on')==0): 
       yellow_led.value(1) # allumer la LED jaune 
    if (uart_in.decode().find('yellow_off')==0): 
       yellow_led.value(0) # eteindre la LED jaune 
# 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

red_led=Pin(23, Pin.OUT) # Configuration de la LED rouge

green_led=Pin(22, Pin.OUT) # Configuration de la LED verte

yellow_led=Pin(21, Pin.OUT) # Configuration de la LED jaune

# 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('red_on')==0):

red_led.value(1) # allumer la LED rouge

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

red_led.value(0) # eteindre la LED rouge

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

green_led.value(1) # allumer la LED verte

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

green_led.value(0) # eteindre la LED verte

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

yellow_led.value(1) # allumer la LED jaune

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

yellow_led.value(0) # eteindre la LED jaune

# 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 LED rouge dans la partie Designer.

6- Ajoutez un autre bouton pour allumer et éteindre la LED verte dans la partie Designer.

7- Ajoutez un autre bouton pour allumer et éteindre la LED jaune dans la partie Designer.

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

Les composants nécessaires pour contrôler trois LEDs par la carte ESP32

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

1- 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 la LED.

2- Trois LEDs :

trois LEDs

Sélectionnez la LED de votre choix, en tenant compte de la couleur et de la tension de fonctionnement appropriées. Assurez-vous également d'avoir une résistance appropriée pour limiter le courant de la LED.

3- Trois résistances :

Vous aurez besoin d'une résistance pour limiter le courant traversant la LED et éviter de l'endommager. La valeur de la résistance peut être calculée en utilisant la loi d'Ohm, en fonction de la tension de fonctionnement de la LED et du courant souhaité. Par exemple, pour une LED rouge typique avec une tension de 2V et un courant de 20mA, une résistance d'environ 220 ohms peut être utilisée (R = (Vcc - Vled) / Iled).

4- Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

5- 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, la LED et la résistance.

Montage de la carte ESP32 avec trois LEDs

Pour monter la carte ESP32 avec trois LEDs, on peut suivre les étapes suivantes:

1- Placez la carte ESP32 sur la plaque d'essai.

2- Insérez les LEDs dans la plaque d'essai en les connectant aux broches de sortie de la carte ESP32. Par exemple, connectez la LED rouge à la broche GPIO 23, la LED verte à la broche GPIO 22 et la LED jaune à la broche GPIO 21. Assurez-vous d'insérer correctement les LED, en veillant à respecter la polarité (anode et cathode).

3- Connectez une résistance en série avec chaque LED. La résistance doit être connectée entre la broche GPIO correspondante et la borne positive (anode) de la LED.

4- Connectez la borne négative (cathode) de chaque LED à la masse (GND) de la carte ESP32.

5- Assurez-vous que toutes les connexions sont correctement réalisées et que rien n'est court-circuité.

Une fois le montage terminé, vous pouvez programmer la carte ESP32 pour contrôler les LEDs. Par exemple, vous pouvez utiliser le langage de programmation Micropython pour allumer et éteindre les LEDs dans des séquences spécifiques, en utilisant les fonctions de contrôle des broches GPIO de l'ESP32.