Projet 1:

Faire clignoter une LED (avec un intervalle de 1 seconde) branché sur la carte
ESP32 sur le port 23.

Montage:

Carte ESP32 , lampe LED, resistance de 220 Ω

Une diode électroluminescente, ou LED pour "Light-Emitting Diode", est polarisée, elle ne
s’allume que lorsque les pattes sont connectées dans un sens bien déterminé.
Resistance : ajouter une résistance en série avec la LED afin de limiter le courant qui va la
parcourir
La carte Esp32 possède un microcontrôleur facilement programmable ainsi que de
nombreuses entrées-sorties.
Croquis Arduino IDE:

// ledPin est le pin GPIO 23 de la carte ESP32

const int ledPin = 23;

// la fonction setup s'exécute lors d'un reset ou de mise sous tension de la carte
void setup() {
// initialiser le pin numérique ledPin comme pin de sortie.
pinMode(ledPin, OUTPUT);
}

// la fonction loop est une boucle infinie

void loop() {
digitalWrite(ledPin, HIGH); // Allumer la LED (HIGH)
delay(1000); // attendre 1 seconde
digitalWrite(ledPin, LOW); // Eteindre la LED (LOW)
delay(1000); // attendre 1 seconde
}

Code MicroPython :
import time
from machine import Pin # importer pin à partir du module machine

led=Pin(23, Pin.OUT) # Définir le pin 23 comme output(sortie)

while True: # boucle while , boucle infinie puisque condition toujours vrai ->True
led.value(1) # Allumer la LED
time.sleep(1) # attendre 1 seconde
led.value(0) # Eteindre la LED
time.sleep(1) # attendre 1 seconde
Remarque: Pour allumer/éteindre la lampe LED, on peut aussi utiliser led.on() et led.off()
Projet 2:

Allumer une lampe LED par le toucher du pin GPIO4.

Montage:
Carte ESP32 , lampe LED, resistance de 220 Ω

Croqui Arduino IDE:

// choisir les pins

const int touchPin = 4;
const int ledPin = 23;

// Choisir le seuil
const int seuil = 20;
// variable pour stocker la valeur du capteur capacitif
int touchValue;
void setup(){
Serial.begin(115200);
delay(1000); // pause d'une seconde
// initialiser le pin(broche) LED comme sortie(output):
pinMode (ledPin, OUTPUT);
}

void loop(){
// lire la valeur sur le touchpin:
touchValue = touchRead(touchPin);
Serial.print(touchValue);
// vérifier si touchvalue < seuil
//si oui mettre ledPin à la valeur HIGH
if(touchValue < seuil){
// Allumer la lampe LED
digitalWrite(ledPin, HIGH);
Serial.println(" - LED on");
}
else{
// Eteindre la lampe LED
digitalWrite(ledPin, LOW);
Serial.println(" - LED off");
}
delay(500);
}

Code MicroPython :
from machine import Pin,TouchPad

led=Pin(23,Pin.OUT)
touch0=TouchPad(Pin(4))
seuil=100 #configurer le seuil pour lequel le pin est
considéré comme touché

while True:
touch0.config(seuil)
print(touch0.read()) # lire puis afficher la valeur sur
le touchpin
if touch0.read()<100: # vérifier si la valeur sur le
touchpin < seuil
led.on() # Allumer la lampe LED
else:
led.off() # Eteindre la lampe LED
Projet 3

Commander une lampe LED par wifi (éteindre et allumer)

Montage:
Carte ESP32 , lampe LED, resistance de 220 Ω

Principe:
On va se connecter au réseau WiFi disponible puis créer un serveur web sur
la cate ESP32 enfin accéder à la carte via son adresse IP pour commander le
pin23 dans notre exemple.
Croquis Arduino IDE:
#include <WiFi.h>

const char* ssid = "Votre_SSID";

const char* password = "Votre_Mot_de_Passe";

const int relaisPin = 2; // Broche du relais connectée à la

lampe

void setup() {
pinMode(relaisPin, OUTPUT);
digitalWrite(relaisPin, LOW); // Éteindre la lampe au
démarrage

// Connexion au réseau WiFi

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connexion au WiFi en cours...");
}
Serial.println("Connecté au WiFi");
}

void loop() {
// Écouter les commandes de contrôle
if (Serial.available() > 0) {
char command = Serial.read();
if (command == '1') {
digitalWrite(relaisPin, HIGH); // Allumer la lampe
} else if (command == '0') {
digitalWrite(relaisPin, LOW); // Éteindre la lampe
}
}
}

Code MicroPython :

import usocket as socket

from machine import Pin
import network

ssid = 'NOM_RESEAU_WIFI'
password = 'MOT_DE_PASSE_WIFI'

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass

print('connexion établie')
print(station.ifconfig())

led = Pin(23, Pin.OUT)

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(5)

while True:
conn, addr = s.accept()
print('Connexion de = %s' % str(addr))
request = conn.recv(1024)
request = str(request)
print('Contenu = %s' % request)
led_on = request.find('/?led=on')
led_off = request.find('/?led=off')
if led_on == 6:
print('LED ON')
led.value(1)
if led_off == 6:
print('LED OFF')
led.value(0)

response ="""<h1> <a href="/?led=on"><button style="display:

block; width: 100%;font-size: 100px;">ON</button></a></h1>
<h1><a href="/?led=off"><button style="display: block;width:
100%;font-size: 100px;">OFF</button></a></h1>"""

conn.send('HTTP/1.1 200 OK\n')

conn.send('Content-Type: text/html\n')
conn.send('Connection: close\n\n')
conn.sendall(response)
conn.close()
Projet 4:

Commander une lampe par wifi (éteindre et allumer)

Afficher la solution

Montage:
Carte ESP32 , lampe, relais 5V

Un relais est un commutateur automatique permettant de commander un

circuit à courant fort avec un signal à courant faible.
Entrées:

 GND:Conneté au GND (0 V)
 VCC:Connecté au 5V
 SIG: Permet de contrôler le relais (plus que 2.0 V permet de l'activer)

Sorties:
  NO:Normally Open,est connecté au COM lorsque SIG est activé (High)
 COM:Common pin
 NC:Normally Closed, est connecté au COM lorsque SIG est désactivé
(LOW)

Principe:
On va se connecter au réseau WiFi disponible puis créer un serveur web sur
la cate ESP32 enfin accéder à la carte via son adresse IP pour commander le
pin23 dans notre exemple. (le même principe que la commande d'une lampe
LED et le même programme installé sur la carte)

Croquis Arduino IDE:

Code MicroPython :

import usocket as socket

from machine import Pin
import network

ssid = 'NOM_RESEAU_WIFI'
password = 'MOT_DE_PASSE_WIFI'

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:

pass

print('connexion établie')
print(station.ifconfig())

led = Pin(23, Pin.OUT)

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(5)

while True:
conn, addr = s.accept()
print('Connexion de = %s' % str(addr))
request = conn.recv(1024)
request = str(request)
print('Contenu = %s' % request)
led_on = request.find('/?led=on')
led_off = request.find('/?led=off')
if led_on == 6:
print('LED ON')
led.value(1)
if led_off == 6:
print('LED OFF')
led.value(0)

response ="""<h1> <a href="/?led=on"><button style="display:

block; width: 100%;font-size: 100px;">ON</button></a></h1>
<h1><a href="/?led=off"><button style="display: block;width:
100%;font-size: 100px;">OFF</button></a></h1>"""

conn.send('HTTP/1.1 200 OK\n')

conn.send('Content-Type: text/html\n')
conn.send('Connection: close\n\n')
conn.sendall(response)
conn.close()
Projet 5:

Allumer une LED suivant le niveau de remplissage d'une poubelle (LED verte(espace vide
>10cm)) (LED rouge(espace vide <=10cm) ).

Montage:

Carte ESP32 , capteur ultrason HC-S004, 2 resistances 220 Ω, 2 LED rouge et vert

On peut ausi ajouter un pond diviseur de tension,formé de deux résistances( 1 resistance

2.2kΩ, 1 resistance 3.3kΩ). Le but du pont diviseur est de fournir une tension plus petite à
partir d'une tension plus grande (tension de ECHO du capteur ultrason vers l'entréée GPIO4
de la carte ESP32)
Broches de connexion (capteur ultrason)

 Vcc = Alimentation +5 V DC
 Trig =Entrée de déclenchement de la mesure (Trigger input)
 Echo =Sortie de mesure donnée en écho (Echo output)
 GND = Masse de l'alimentation

Principe:

Le détecteur HC-SR04 utilise les ultrasons pour déterminer la distance à laquelle se trouve un
objet. Son champ de vision est de 90° environ selon l'environnement. Si une impulsion de
plus de 10µS est détectée (sur l'entrée TRIGGER), alors le capteur envoie une série de 8
impulsions à ultrason de 40kHZ et attends le réfléchissement du signal. Lorsque celui-ci est
détecté, une impulsion de durée proportionnelle à la distance mesurée (Plage de mesure : 2 cm
à 400 cm) est envoyée sur la sortie "Echo".

Calcul
Distance parcourue par le son : vitesse du son (340 m/s) * temps aller retour du son /2
Distance = 340m/s * t en sec / 2 = 34000 cm /1000000µs * t en µs /2 = 17 /1000 * t
T = Distance * 1000 /17 = D * 58,82 en µs
Distance en cm = temps propagation en µs / 58
Croquis Arduino IDE:(mesure de distance)
#define TRIG 5 //pin 5 carte UNO pour envoyer pulse de 10µs
#define ECHO 4 // pin 4 carte UNO pour recevoir pulse Echo
const long TIMEOUT = 30000UL; // 30ms soit mesure à moins de 6m25
unsigned long distance; //
void setup() {
pinMode(TRIG,OUTPUT); // configuration pin TRIG en sortie, elle sera raccordée à l'entrée Trig du
capteur HC-SR04
pinMode(ECHO,INPUT); // configuration pin ECHO en entrée, elle sera raccordée à la sortie Echo
du capteur HCSR04
digitalWrite(TRIG, LOW); //Elle doit être à 0 au démarrage
Serial.begin(115200);
}
void loop() {
//création impulsion trigger de 10µs
digitalWrite(TRIG,HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);
//mesure de la distance en cm capteur / cible
distance = pulseIn(ECHO, HIGH, TIMEOUT)/58;
//Affichage mesure toutes les 0.5 seconde
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(500);
}

Pour voir les distances en cm, on peut voir le moniteur série (Outils--> Moniteur
série(Ctr+Maj+M) ou cliquer sur l'icône
Allumage d'une LED suivant une condition:
On va ajouter les instructions permettant d'allumer la LED (Verte) si la
distance est >10 et la LED (Rouge) dans le cas contraire.

Croquis Arduino IDE :(allumage des LED suivant une condition)

#define TRIG 5 //pin 5 carte UNO pour envoyer pulse de 10µs
#define ECHO 4 // pin 4 carte UNO pour recevoir pulse Echo
const long TIMEOUT = 30000UL; // 30ms soit mesure à moins de
6m25
unsigned long distance; //
const int ledPinVert = 22;
const int ledPinRouge = 23;
const int seuil=10;
void setup() {
pinMode(ledPinVert, OUTPUT);
pinMode(ledPinRouge, OUTPUT);
pinMode(TRIG,OUTPUT); // configuration pin TRIG en sortie,
elle sera raccordée à l'entrée Trig du capteur HC-SR04
pinMode(ECHO,INPUT); // configuration pin ECHO en entrée,
elle sera raccordée à la sortie Echo du capteur HCSR04
digitalWrite(TRIG, LOW); //Elle doit être à 0 au démarrage
Serial.begin(115200);
}
void loop() {
//création impulsion trigger de 10µs
digitalWrite(TRIG,HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);
//mesure de la distance en cm capteur / cible
distance = pulseIn(ECHO, HIGH, TIMEOUT)/58;
//Affichage mesure toutes les 0.5 seconde
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(500);
if (distance>seuil) {
digitalWrite(ledPinRouge, LOW); // Eteindre le LED
Rouge(LOW)
digitalWrite(ledPinVert, HIGH); // Allumer le LED Vert
(HIGH)
}
else
{
digitalWrite(ledPinVert, LOW); // Eteindre le LED
Vert(LOW)
digitalWrite(ledPinRouge, HIGH); // Allumer le LED Rouge
(HIGH)
}}
PROJET

Envoyer une notification Push sur son smartphone si l'espace vide dans une
poubelle<=10cm

Montage:
On va garder le même montage que le projet 5:

Principe:
Le détecteur HC-SR04 utilise les ultrasons pour déterminer la distance à
laquelle se trouve un objet. Lorsque la distance >10 une lampe LED verte
s'allume, mais si la distance <=10 une lampe LED Rouge est allumée et une
notification est envoyée au smartphone indiquant que la poubelle est pleine
et la distance vide qui reste.

Création de notification :
Sur un mobile, une notification push est un message d’alerte reçu via une
application que l’on peut ouvrir, supprimer, autoriser ou bloquer. Pour créer
une notification on va suivre les étapes suivantes:

Etape1: Configuration du service PushBullet

Pushbullet est un service Internet permettant d'envoyer des SMS, de gérer
des notifications et d'envoyer des fichiers entre vos appareils mobiles et votre
ordinateur.
Sur le PC : On va commencer par créer un compte gratuit en utilisant un
compte existant google ou facbook (sign up with google ou facebook).
https://www.pushbullet.com/ Lien
Sur le smartphone :
Dans google Play chercher PushBullet puis l'installer puis choisir le même
compte utilisé sur le PC.

Sur le PC :
Dans le menu Devices sur pc vous devez retrouver votre smartphone.

Ouvrir le menu settings puis cliquer sur Create access Token

Copier le Token généré dans un fichier texte pour une utilisation ultérieure.

Etape2: Configuration de Pushingbox :

PushingBox est un service de notification dans le cloud.
On va créer un compte gratuit en utilisant un compte existant google (login
with google).
https://www.pushingbox.com/ Lien
Aller à My services en suite Add a service sélectionner à partir de la
liste Pushbullet puis Select this service
dans la fenêtre suivante spécifier un nom puis coller pushbullet Token (précédemment enregistré
dans un fichier texte) dans Access Token puis valider.

Ouvrir le menu My scenarios saisir le nom de votre scénario puis cliquer sur Add
Cliquer sur le bouton Add an action puis Add an action with this service

Dans la fenêtre suivante saisir le titre et le contenu du message de

notification, notez l'utilisation de $parma$ qui est une variable qui va
contenir la mesure capturée.
Il ne reste que noter le Device ID puisqu'on va l'utiliser dans notre
programme par la suite.

Le code suivant permet de se connecter au WiFi spécifié puis si la distance

mesurée est <=10 alors envoi une requette HTTP à l'API pushingbox relatif
au Device ID ce qui va permettre d'envoyer une notification à votre
smartphone.

Croquis Arduino IDE:

#include <WiFi.h>
#include <WiFiMulti.h>

WiFiMulti WiFiMulti;
WiFiClient client;
// Pushingbox API
char *api_server = "api.pushingbox.com";
char *deviceId = "v5FE1TE24CA4C6FB32";

#define TRIG 5 //pin 5 carte UNO pour envoyer pulse de 10µs

#define ECHO 4 // pin 4 carte UNO pour recevoir pulse Echo
const long TIMEOUT = 30000UL; // 30ms soit mesure à moins de
6m25
unsigned long distance; //
const int ledPinVert = 22;
const int ledPinRouge = 23;
const int seuil=10;

void setup()
{
pinMode(ledPinVert, OUTPUT);
pinMode(ledPinRouge, OUTPUT);
pinMode(TRIG,OUTPUT); // configuration pin TRIG en sortie,
elle sera raccordée à l'entrée Trig du capteur HC-SR04
pinMode(ECHO,INPUT); // configuration pin ECHO en entrée,
elle sera raccordée à la sortie Echo du capteur HCSR04
digitalWrite(TRIG, LOW); //Elle doit être à 0 au démarrage
Serial.begin(115200);
delay(10);

// We start by connecting to a WiFi network

WiFiMulti.addAP("SSID_WIFI", "PASSWORD_WIFI");

Serial.println();
Serial.println();
Serial.print("En attente du WiFi... ");

while(WiFiMulti.run() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("");
Serial.println("WiFi connecté");
Serial.println("addresse IP: ");
 Serial.println(WiFi.localIP());

delay(500);
}

void loop()
{
//création impulsion trigger de 10µs
digitalWrite(TRIG,HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);
//mesure de la distance en cm capteur / cible
distance = pulseIn(ECHO, HIGH, TIMEOUT)/58;
//Affichage mesure toutes les 0.5 seconde
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(500);

if (distance>seuil) {
digitalWrite(ledPinRouge, LOW); // Eteindre le LED
Rouge(LOW)
digitalWrite(ledPinVert, HIGH); // Allumer le LED Vert
(HIGH)

}
else
{
digitalWrite(ledPinVert, LOW); // Eteindre le LED
Vert(LOW)
digitalWrite(ledPinRouge, HIGH); // Allumer le LED Rouge
(HIGH)
sendNotification(distance);

}
}

void sendNotification(int param) {

Serial.println("Sending notification to " +
String(api_server));
if (client.connect(api_server, 80)) {
Serial.println("Connecté au serveur");
String message = "devid=" + String(deviceId) +
"&param=" + String(param) +
"";
client.print("POST /pushingbox HTTP/1.1\n");
client.print("Host: api.pushingbox.com\n");
client.print("Connection: close\n");
client.print("Content-Type: application/x-www-form-
urlencoded\n");
client.print("Content-Length: ");
 client.print(message.length());
client.print("\n\n");
client.print(message);
}
client.stop();
Serial.println("Notification envoyée!");
}
Copier le code

Pour voir les distances en cm, et la tentative d'envoi de notification on peut

voir le moniteur série (Outils--> Moniteur série(Ctr+Maj+M) ou cliquer sur
l'icône
Test de distance à intervalle régulier:
On va ajouter les instructions permettant de faire le test de distance à
intervalle régulier(1 minute=60000 millisecondes)), au lieu de faire des test
en contenu et plusieurs notifications.

Croquis Arduino IDE :(faire des tests à intervalle régulier(1 minute))

#include <WiFi.h>
#include <WiFiMulti.h>

WiFiMulti WiFiMulti;
WiFiClient client;
// Pushingbox API
char *api_server = "api.pushingbox.com";
char *deviceId = "v5FE1TE24CA4C6FB32";

#define TRIG 5 //pin 5 carte UNO pour envoyer pulse de 10µs

#define ECHO 4 // pin 4 carte UNO pour recevoir pulse Echo
const long TIMEOUT = 30000UL; // 30ms soit mesure à moins de 6m25
unsigned long distance; //
const int ledPinVert = 22;
const int ledPinRouge = 23;
const int seuil=10;

unsigned long intervalle=60000;

unsigned long temps_courant;
unsigned long temps_mesure=0;

void setup()
{
pinMode(ledPinVert, OUTPUT);
pinMode(ledPinRouge, OUTPUT);
pinMode(TRIG,OUTPUT); // configuration pin TRIG en sortie, elle sera raccordée à l'entrée
Trig du capteur HC-SR04
pinMode(ECHO,INPUT); // configuration pin ECHO en entrée, elle sera raccordée à la
sortie Echo du capteur HCSR04
digitalWrite(TRIG, LOW); //Elle doit être à 0 au démarrage
Serial.begin(115200);
delay(10);

// We start by connecting to a WiFi network

WiFiMulti.addAP("SSID_WIFI", "PASSWORD_WIFI");

Serial.println();
Serial.println();
Serial.print("En attente du WiFi... ");

while(WiFiMulti.run() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}

Serial.println("");
Serial.println("WiFi connecté");
Serial.println("addresse IP: ");
Serial.println(WiFi.localIP());

delay(500);
}

void loop()
{
//création impulsion trigger de 10µs
digitalWrite(TRIG,HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);
//mesure de la distance en cm capteur / cible
distance = pulseIn(ECHO, HIGH, TIMEOUT)/58;
//Affichage mesure toutes les 0.5 seconde
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(500);

if (distance>seuil) {
digitalWrite(ledPinRouge, LOW); // Eteindre le LED Rouge(LOW)
digitalWrite(ledPinVert, HIGH); // Allumer le LED Vert (HIGH)

}
else
{
temps_courant=millis();
if (temps_courant - temps_mesure>= intervalle) { temps_mesure=millis();
digitalWrite(ledPinVert, LOW); // Eteindre le LED Vert(LOW)
digitalWrite(ledPinRouge, HIGH); // Allumer le LED Rouge (HIGH)
sendNotification(distance); }

}
}

void sendNotification(int param) {

Serial.println("Sending notification to " + String(api_server));
if (client.connect(api_server, 80)) {
Serial.println("Connecté au serveur");
String message = "devid=" + String(deviceId) +
"&param=" + String(param) +
"";
client.print("POST /pushingbox HTTP/1.1\n");
client.print("Host: api.pushingbox.com\n");
client.print("Connection: close\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(message.length());
client.print("\n\n");
client.print(message);
}
client.stop();
Serial.println("Notification envoyée!");
}