ESP32 Robot voiture à deux roues commandé via Bluetooth

ESP32 19-12-24

17 0

Plan de tutoriel

1- Fonctionnement du robot voiture commandé par ESP32 et Bluetooth

2- Matériel nécessaire

3- Montage du robot

4- Programmer de la carte ESP32 avec le Micropython

Fonctionnement du robot voiture commandé par ESP32 et Bluetooth

Voici une description détaillée du fonctionnement d'une voiture robot à deux roues utilisant un ESP32 via Bluetooth.

Étape 1 : Connexion Bluetooth

1- L'application mobile recherche les périphériques Bluetooth.

2- Une fois apparié, l'application se connecte à l'ESP32.

3- L'ESP32 attend les commandes envoyées par l'application.

Étape 2 : Réception des commandes

1- L'utilisateur appuie sur un bouton de commande dans l'application (par exemple, "Avancer").

2- L'application envoie le mot "Avancer" à l'ESP32 via Bluetooth.

3- L'ESP32 lit ce mot et met à jour l’état du robot en temps réel.

Matériel nécessaire

Carte ESP32

ESP32 card

C'est le cerveau du robot. Il reçoit les commandes via Bluetooth et contrôle les moteurs via le module L298N en envoyant des signaux numériques.

Module L298N

Il pilote de moteur et reçoit les commandes de l'ESP32 et contrôle la vitesse et la direction des moteurs.

Kit robot voitures de 2 roues

Moteurs DC (2 moteurs pour les roues).

Châssis : Structure du robot avec deux roues motrices et une roue folle.

Module Adaptateur 3.3V/5V :

Un module adaptateur 3.3V/5V est un dispositif électronique qui permet de convertir une tension d'entrée (généralement de 5V ou 9V) en une sortie régulée à 3.3V ou 5V, selon les besoins des composants du système.

Batterie :

Fournit l’énergie aux moteurs et à l’ESP32.

Câblage et connecteurs :

Fils de connexion

Des fils électriques et des connecteurs seront nécessaires pour relier les différents composants entre eux

Plaque d'essai (Breadboard) :

plaque d'essai

On utilise la plaque d'essai pour faciliter le câblage des différents composants.

Montage du robot

Pour réaliser le montage il faut connecter:

- la broche N°23 de la carte ESP32 à la broche ENA du module L298N.

- la broche N°22 de la carte ESP32 à la broche IN1 du module L298N.

- la broche N°21 de la carte ESP32 à la broche IN2 du module L298N.

- la broche N°19 de la carte ESP32 à la broche IN3 du module L298N.

- la broche N°18 de la carte ESP32 à la broche IN4 du module L298N.

- la broche N°5 de la carte ESP32 à la broche ENB du module L298N.

- la broche GND de la carte ESP32 à la broche GND du module L298N.

- la broche 5V de la carte ESP32 à la broche 5v du module de l’alimentation

- la broche GND de la carte ESP32 à la borne (-) du module de l’alimentation

-la broche 12V du module L298N à la broche 5V du module de l’alimentation

- les deux moteurs de la voiture à la carte L298N

Programmer de la carte ESP32 avec le Micropython

Voici un code simplifié pour contrôler la voiture via Bluetooth :

Tout à d'abord il faut :

1- utiliser le Firmware suivant : esp32-20210902-v1.17.bin.

2- importer :

a- la bibliothèque DCMotor.py pour commander le module L298N.

b- les deux bibliothèques :ble_uart_peripheral.py et ble_advertising.pypour la communication Bluetooth

from machine import UART
from DCMotor import DCMotor 
from machine import Pin, PWM
from time import sleep
import bluetooth
from ble_uart_peripheral import BLEUART

import time
import utime
frequency = 15000       
pin1 = Pin(22, Pin.OUT)    
pin2 = Pin(21, Pin.OUT)  
pin3 = Pin(19, Pin.OUT)    
pin4 = Pin(18, Pin.OUT)  
enable = PWM(Pin(23), frequency)  
enable1 = PWM(Pin(5), frequency)
dc_motor = DCMotor(pin1, pin2, enable)      
dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)
dc_motor1 = DCMotor(pin3, pin4, enable1)      
dc_motor1 = DCMotor(pin3, pin4, enable1, 350, 1023)

# 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('avant')==0): 
       dc_motor.forward(100) # la voiture avance
       dc_motor1.forward(100)
    if (uart_in.decode().find('droite')==0): 
       dc_motor.forward(100) # la voiture tourne a droite
       dc_motor1.forward(10)
    if (uart_in.decode().find('gauche')==0): 
       dc_motor.forward(10) # la voiture tourne a gauche
       dc_motor1.forward(100)
    if (uart_in.decode().find('arriere')==0): 
       dc_motor.backwards(100) # la voiture recule
       dc_motor1.backwards(100)
    if (uart_in.decode().find('stop')==0): 
       dc_motor.stop() # la voiture tourne a droite
       dc_motor1.stop()    

# Map ISR to UART read interrupt
uart.irq(handler=on_rx)
uart.close()

from machine import UART

from DCMotor import DCMotor

from machine import Pin, PWM

from time import sleep

import bluetooth

from ble_uart_peripheral import BLEUART

import time

import utime

frequency = 15000

pin1 = Pin(22, Pin.OUT)

pin2 = Pin(21, Pin.OUT)

pin3 = Pin(19, Pin.OUT)

pin4 = Pin(18, Pin.OUT)

enable = PWM(Pin(23), frequency)

enable1 = PWM(Pin(5), frequency)

dc_motor = DCMotor(pin1, pin2, enable)

dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)

dc_motor1 = DCMotor(pin3, pin4, enable1)

dc_motor1 = DCMotor(pin3, pin4, enable1, 350, 1023)

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

dc_motor.forward(100) # la voiture avance

dc_motor1.forward(100)

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

dc_motor.forward(100) # la voiture tourne a droite

dc_motor1.forward(10)

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

dc_motor.forward(10) # la voiture tourne a gauche

dc_motor1.forward(100)

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

dc_motor.backwards(100) # la voiture recule

dc_motor1.backwards(100)

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

dc_motor.stop() # la voiture tourne a droite

dc_motor1.stop()

# Map ISR to UART read interrupt

uart.irq(handler=on_rx)

uart.close()

Programmation d'une application mobile avec App Inventor

L'application mobile créée avec MIT App Inventor permet à l'utilisateur de contrôler le robot via Bluetooth.

Voici un exemple simple d'interface dans l'application :

Programmation des blocs

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

2- À 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.