ESP32-CAM et capteur infrarouge passif (PIR)

Le projet que je vais décrire dans cet article consiste à faire en sorte que l'ESP32-CAM prenne automatiquement des photos (et les enregistre sur une carte microSD) chaque fois qu'un capteur infrarouge passif (PIR) détecte une présence. Ça peut faire partie d'un système d'alarme (prendre les photos d'un intrus dans une pièce) , constituer un dispositif qui photographie des animaux sauvages, etc.

Il y quelques années, j'avais rédigé un article assez détaillé sur les capteurs PIR. Le modèle que j'utilise est muni d'un régulateur de tension: on doit l'alimenter avec 5 V pour qu'il fonctionne correctement, mais son signal de sortie passe de 0 V à 3,3 V lorsque la présence d'un humain ou d'un animal est détectée (N.B.: ce n'est probablement pas le cas pour tous les modules PIR disponibles sur le marché).

Une pénurie de broches

La caméra de l'ESP32-CAM utilise déjà un très grand nombre d'entrées/sorties de l'ESP32, ce qui explique pourquoi un  module ESP32-CAM comporte beaucoup moins de broches qu'on module ESP32 conventionnel. Mais lorsque vous utilisez le lecteur de cartes microSD intégré au module, la situation devient vraiment délicate: à lui-seul, le lecteur de cartes microSD accapare 6 broches (GPIO 2, 4, 12, 13, 14 et 15).  Puisque GPIO 0 , 1 et 3 sont utilisés pour la programmation de la carte, il ne reste que GPIO 16;  mais en plus d'être reliée à une résistance pull up qui la tient par défaut au niveau logique haut, cette broche est liée à la mémoire PSRAM.

La solution que j'ai choisie consiste à utiliser le module de carte SD en mode 1 bit plutôt qu'en mode 4 bits. C'est en principe un peu plus lent, mais ça permet de rendre disponibles les broches GPIO 4, 12 et 13.

J'ai donc branché la sortie du capteur PIR à la broche D13 de l'ESP32-CAM.

Des faux positifs?

Si votre capteur PIR détecte une présence même lorsqu'il n'y a personne, vous pouvez diminuer sa sensibilité en ajustant le potentiomètre "Sensitivity". Dans mon cas, il s'est avéré nécessaire d'alimenter le capteur PIR et l'ESP32-CAM de façon indépendante. Lorsqu'ils partageaient tous les deux la même alimentation de 5 V, ils se perturbaient mutuellement: des photos étaient prises sans raison apparente, et l'ESP32-CAM redémarrait parfois de façon impromptue.

Sketch

(En cas de besoin, vous pouvez consulter cet article pour plus de détails concernant la façon de programmer l'ESP32-CAM avec l'IDE Arduino.)

Voici un premier sketch plutôt simple qui n'exploite pas les capacités WIFI de l'ESP32-CAM. Lorsque la broche D13 de l'ESP32-CAM se trouve au niveau logique "Haut" (parce que le capteur PIR a détecté une présence), des photos sont prises et enregistrées sur la carte microSD. Vous devez ensuite éjecter la carte et l'insérer dans un autre appareil pour voir son contenu.

-

	/*
	* ESP32-CAM PIR
	*
	* Capteur de mouvement PIR branché à une ESP32-CAM.
	*
	* Des photos sont prises lorsqu'un mouvement est détecté.
	* Version sans WIFI
	*
	* Pour plus d'infos:
	* https://electroniqueamateur.blogspot.com/2020/07/esp32-cam-et-capteur-infrarouge-passif.html
	*
	*/
	#include "FS.h" // manipulation de fichiers
	#include "SD_MMC.h" // carte SD
	#include "esp_camera.h" // caméra!
	static bool cartePresente = false;
	int numero_fichier = 0; // numéro de la photo (nom du fichier)
	int brochePIR = 13; // capteur PIR branché à la broche GPIO13.
	// prise de la photo et création du fichier jpeg
	void enregistrer_photo (void)
	{
	char adresse[20] = ""; // chemin d'accès du fichier .jpeg
	camera_fb_t * fb = NULL; // frame buffer
	// prise de la photo
	fb = esp_camera_fb_get();
	if (!fb) {
	Serial.println("Echec de la prise de photo.");
	return;
	}
	numero_fichier = numero_fichier + 1;
	// enregitrement du fichier sur la carte SD
	sprintf (adresse, "/%d.jpg", numero_fichier);
	fs::FS &fs = SD_MMC;
	File file = fs.open(adresse, FILE_WRITE);
	if (!file) {
	Serial.println("Echec lors de la creation du fichier.");
	}
	else {
	file.write(fb->buf, fb->len); // payload (image), payload length
	Serial.printf("Fichier enregistre: %s\n", adresse);
	}
	file.close();
	esp_camera_fb_return(fb);
	}
	void setup(void) {
	// définition des broches de la caméra pour le modèle AI Thinker - ESP32-CAM
	camera_config_t config;
	config.ledc_channel = LEDC_CHANNEL_0;
	config.ledc_timer = LEDC_TIMER_0;
	config.pin_d0 = 5;
	config.pin_d1 = 18;
	config.pin_d2 = 19;
	config.pin_d3 = 21;
	config.pin_d4 = 36;
	config.pin_d5 = 39;
	config.pin_d6 = 34;
	config.pin_d7 = 35;
	config.pin_xclk = 0;
	config.pin_pclk = 22;
	config.pin_vsync = 25;
	config.pin_href = 23;
	config.pin_sscb_sda = 26;
	config.pin_sscb_scl = 27;
	config.pin_pwdn = 32;
	config.pin_reset = -1;
	config.xclk_freq_hz = 20000000;
	config.pixel_format = PIXFORMAT_JPEG; //YUV422|GRAYSCALE|RGB565|JPEG
	config.frame_size = FRAMESIZE_VGA; // QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
	config.jpeg_quality = 10; // 0-63 ; plus bas = meilleure qualité
	config.fb_count = 2; // nombre de frame buffers
	// initialisation de la caméra
	esp_err_t err = esp_camera_init(&config);
	if (err != ESP_OK) {
	Serial.printf("Echec de l'initialisation de la camera, erreur 0x%x", err);
	return;
	}
	sensor_t * s = esp_camera_sensor_get();
	// initialisation de la carte micro SD
	// en mode 1 bit: plus lent, mais libère des broches
	if (SD_MMC.begin("/sdcard",true)) {
	uint8_t cardType = SD_MMC.cardType();
	if (cardType != CARD_NONE) {
	Serial.println("Carte SD Initialisee.");
	cartePresente = true;
	}
	}
	pinMode(brochePIR,INPUT);
	}
	void loop(void) {
	if (digitalRead(brochePIR)){
	enregistrer_photo();
	Serial.print("Nouvelle photo! ");
	Serial.println(numero_fichier);
	delay(300);
	}
	}

view raw ESP32-CAM_PIR.ino hosted with ❤ by GitHub

-

Voici un  deuxième exemple, plus élaboré, qui permet de voir le contenu de la carte à distance, grâce à une page web générée par l'ESP32-CAM (voir ce précédent article pour plus d'informations).

-

	/*
	ESP32-CAM PIR WIFI
	Capteur de mouvement PIR branché à une ESP32-CAM.
	Lorsqu'un mouvement est détectée, des photos sont prises.
	Le contenu de la carte SD peut être consulté par WIFI.
	Plus d'infos sur le blog:
	https://electroniqueamateur.blogspot.com/2020/07/esp32-cam-et-capteur-infrarouge-passif.html
	*/
	#include <WiFi.h>
	#include <WiFiClient.h>
	#include <WebServer.h>
	#include "FS.h" // manipulation de fichiers
	#include "SD_MMC.h" // carte SD
	#include "esp_camera.h" // caméra!
	// écrivez le nom et le mot de passe de votre réseau WIFI
	const char* ssid = "**********";
	const char* password = "**********";
	WebServer server(80);
	static bool cartePresente = false;
	int numero_fichier = 0; // numéro de la photo (nom du fichier)
	int brochePIR = 13; // capteur PIR branché à la broche GPIO13.
	// prise de la photo et création du fichier jpeg
	void enregistrer_photo (void)
	{
	char adresse[20] = ""; // chemin d'accès du fichier .jpeg
	camera_fb_t * fb = NULL; // frame buffer
	// prise de la photo
	fb = esp_camera_fb_get();
	if (!fb) {
	Serial.println("Echec de la prise de photo.");
	return;
	}
	numero_fichier = numero_fichier + 1;
	// enregitrement du fichier sur la carte SD
	sprintf (adresse, "/%d.jpg", numero_fichier);
	fs::FS &fs = SD_MMC;
	File file = fs.open(adresse, FILE_WRITE);
	if (!file) {
	Serial.println("Echec lors de la creation du fichier.");
	}
	else {
	file.write(fb->buf, fb->len); // payload (image), payload length
	Serial.printf("Fichier enregistre: %s\n", adresse);
	}
	file.close();
	esp_camera_fb_return(fb);
	}
	void returnOK() {
	server.send(200, "text/plain", "");
	}
	void returnFail(String msg) {
	server.send(500, "text/plain", msg + "\r\n");
	}
	// Affichage d'un fichier présent sur la carte
	bool loadFromSdCard(String path) {
	String dataType = "text/plain";
	if (path == "/") {
	printDirectory();
	}
	else {
	if (path.endsWith(".src")) {
	path = path.substring(0, path.lastIndexOf("."));
	} else if (path.endsWith(".htm")) {
	dataType = "text/html";
	} else if (path.endsWith(".css")) {
	dataType = "text/css";
	} else if (path.endsWith(".js")) {
	dataType = "application/javascript";
	} else if (path.endsWith(".png")) {
	dataType = "image/png";
	} else if (path.endsWith(".gif")) {
	dataType = "image/gif";
	} else if (path.endsWith(".jpg")) {
	dataType = "image/jpeg";
	} else if (path.endsWith(".ico")) {
	dataType = "image/x-icon";
	} else if (path.endsWith(".xml")) {
	dataType = "text/xml";
	} else if (path.endsWith(".pdf")) {
	dataType = "application/pdf";
	} else if (path.endsWith(".zip")) {
	dataType = "application/zip";
	}
	fs::FS &fs = SD_MMC;
	File dataFile = fs.open(path.c_str());
	if (!dataFile) {
	return false;
	}
	if (server.hasArg("download")) {
	dataType = "application/octet-stream";
	}
	if (server.streamFile(dataFile, dataType) != dataFile.size()) {
	Serial.println("Sent less data than expected!");
	}
	dataFile.close();
	}
	return true;
	}
	// utilisé lors de la suppression d'un fichier
	void deleteRecursive(String path) {
	fs::FS &fs = SD_MMC;
	File file = fs.open((char *)path.c_str());
	if (!file.isDirectory()) {
	file.close();
	fs.remove((char *)path.c_str());
	return;
	}
	file.rewindDirectory();
	while (true) {
	File entry = file.openNextFile();
	if (!entry) {
	break;
	}
	String entryPath = path + "/" + entry.name();
	if (entry.isDirectory()) {
	entry.close();
	deleteRecursive(entryPath);
	} else {
	entry.close();
	fs.remove((char *)entryPath.c_str());
	}
	yield();
	}
	fs.rmdir((char *)path.c_str());
	file.close();
	}
	// suppression d'un fichier
	void handleDelete() {
	fs::FS &fs = SD_MMC;
	if (server.args() == 0) {
	return returnFail("Mauvais arguments?");
	}
	String path = server.arg(0);
	if (path == "/" || !fs.exists((char *)path.c_str())) {
	returnFail("BAD PATH");
	return;
	}
	deleteRecursive(path);
	// on affiche un message de confirmation
	server.setContentLength(CONTENT_LENGTH_UNKNOWN);
	server.send(200, "text/html", "");
	WiFiClient client = server.client();
	server.sendContent("<h1>Le fichier a &eacute;t&eacute; supprim&eacute;</h1>");
	server.sendContent("<p><a href = / > Retour &agrave; la liste des fichiers </a></p>");
	}
	// Affichage du contenu de la carte
	void printDirectory() {
	fs::FS &fs = SD_MMC;
	String path = "/";
	File dir = fs.open((char *)path.c_str());
	path = String();
	if (!dir.isDirectory()) {
	dir.close();
	return returnFail("PAS UN REPERTOIRE");
	}
	dir.rewindDirectory();
	server.setContentLength(CONTENT_LENGTH_UNKNOWN);
	server.send(200, "text/html", "");
	WiFiClient client = server.client();
	server.sendContent("<h1>Contenu de la carte SD</h1>");
	for (int cnt = 0; true; ++cnt) {
	File entry = dir.openNextFile();
	if (!entry) {
	break;
	}
	String output;
	output += "<a href = ";
	output += entry.name();
	output += "> ";
	output += entry.name();
	// on ajoute un bouton delete:
	output += "</a> &nbsp; &nbsp; &nbsp; &nbsp; <a href = /delete?url=";
	output += entry.name();
	output += "> [Supprimer] </a> <br>";
	server.sendContent(output);
	entry.close();
	}
	dir.close();
	}
	// on tente d'afficher le fichier demandé. Sinon, message d'erreur
	void handleNotFound() {
	if (cartePresente && loadFromSdCard(server.uri())) {
	return;
	}
	String message = "Carte SD non detectee ou action imprevue\n\n";
	message += "URI: ";
	message += server.uri();
	message += "\nMethod: ";
	message += (server.method() == HTTP_GET) ? "GET" : "POST";
	message += "\nArguments: ";
	message += server.args();
	message += "\n";
	for (uint8_t i = 0; i < server.args(); i++) {
	message += " NAME:" + server.argName(i) + "\n VALUE:" + server.arg(i) + "\n";
	}
	server.send(404, "text/plain", message);
	Serial.print(message);
	}
	void setup(void) {
	// définition des broches de la caméra pour le modèle AI Thinker - ESP32-CAM
	camera_config_t config;
	config.ledc_channel = LEDC_CHANNEL_0;
	config.ledc_timer = LEDC_TIMER_0;
	config.pin_d0 = 5;
	config.pin_d1 = 18;
	config.pin_d2 = 19;
	config.pin_d3 = 21;
	config.pin_d4 = 36;
	config.pin_d5 = 39;
	config.pin_d6 = 34;
	config.pin_d7 = 35;
	config.pin_xclk = 0;
	config.pin_pclk = 22;
	config.pin_vsync = 25;
	config.pin_href = 23;
	config.pin_sscb_sda = 26;
	config.pin_sscb_scl = 27;
	config.pin_pwdn = 32;
	config.pin_reset = -1;
	config.xclk_freq_hz = 20000000;
	config.pixel_format = PIXFORMAT_JPEG; //YUV422|GRAYSCALE|RGB565|JPEG
	config.frame_size = FRAMESIZE_VGA; // QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
	config.jpeg_quality = 10; // 0-63 ; plus bas = meilleure qualité
	config.fb_count = 2; // nombre de frame buffers
	// initialisation de la caméra
	esp_err_t err = esp_camera_init(&config);
	if (err != ESP_OK) {
	Serial.printf("Echec de l'initialisation de la camera, erreur 0x%x", err);
	return;
	}
	sensor_t * s = esp_camera_sensor_get();
	// connexion au WIFI
	Serial.begin(115200);
	WiFi.mode(WIFI_STA);
	WiFi.begin(ssid, password);
	Serial.print("Connexion au reseau Wifi ");
	Serial.println(ssid);
	uint8_t i = 0;
	while (WiFi.status() != WL_CONNECTED && i++ < 20) {//wait 10 seconds
	delay(500);
	}
	if (i == 21) {
	Serial.print("Impossible de se connecter au reseau ");
	Serial.println(ssid);
	while (1) {
	delay(500);
	}
	}
	Serial.print("Connecte a l'adresse IP: ");
	Serial.println(WiFi.localIP());
	// initialisation du web server
	server.on("/delete", HTTP_GET, handleDelete);
	server.onNotFound(handleNotFound);
	server.begin();
	Serial.println("Serveur HTTP en fonction.");
	// initialisation de la carte micro SD
	// en mode 1 bit: plus lent, mais libère des broches
	if (SD_MMC.begin("/sdcard", true)) {
	uint8_t cardType = SD_MMC.cardType();
	if (cardType != CARD_NONE) {
	Serial.println("Carte SD Initialisee.");
	cartePresente = true;
	}
	}
	pinMode(brochePIR, INPUT);
	}
	void loop(void) {
	server.handleClient();
	if (digitalRead(brochePIR)) {
	enregistrer_photo();
	Serial.print("Nouvelle photo! ");
	Serial.println(numero_fichier);
	delay(300);
	}
	}

view raw ESP32-CAM_PIR_WIFI.ino hosted with ❤ by GitHub

-

À lire également:

Mes autres publications concernant l'ESP32-CAM:

• ESP32-CAM: Première utilisation avec l'IDE Arduino
• ESP32-CAM: un web server minimaliste
• ESP32-CAM: enregistrer des photos dans Google Drive
• ESP32-CAM: enregistrer des photos sur la carte microSD
• ESP32-CAM: gestion à distance de la carte microSD
• Time-lapse avec l'ESP32-CAM
• Mouvement panoramique avec ESP32-CAM et servomoteur
• Les LEDs de l'ESP32-CAM

Yves Pelletier (Twitter, Facebook)

Mesurer la température et l'humidité relative avec un DHT22 (AM2302)

Le capteur DHT22 (aussi appelé AM2302) est spécialement conçu pour mesurer l'humidité relative de l'air, ainsi que la température. Voyons comment l'utiliser avec un Arduino.

Ce capteur contient un condensateur dont la capacité dépend de l'humidité de l'air ambiant. Puisque l'humidité relative dépend aussi de la température, le capteur comporte aussi un thermistor. La température et l'humidité relative sont transmises au microcontrôleur de façon numérique.

Si vous avez un capteur DHT11 plutôt qu'un DHT22, vous obtiendrez des mesures moins précises, mais les deux capteurs s'utilisent de la même façon.

Connexions

Le capteur DHT22 que j'ai utilisé était intégré à un module comportant 3 broches:

• +:  Alimentation de 5 V ou de 3,3 V, selon le niveau logique désiré.

• OUT: À brancher à une entrée numérique du microcontrôleur (j'ai choisi la broche 2 du Uno)

• -: GND

Mon module comporte déjà une résistance de tirage entre la broche + et la broche OUT, il n'a donc pas été nécessaire que j'en installe une moi-même.

Installation de la bibliothèque DHT d'Adafruit

J'ai choisi d'utilise la bibliothèque DHT d'Adafruit, qui peut être utilisée avec les capteurs DHT11, DHT12, DHT21/AM2301  et DHT22/AM2302. Vous pouvez passer par le gestionnaire de bibliothèques de l'IDE Arduino.

L'exemple "DHTtester" fourni avec la bibliothèque permet de vérifier rapidement le bon fonctionnement du capteur. Puisqu'Adafruit se trouve aux États-Unis, ils ont intégré à leur bibliothèque des fonctions qui permettent d'obtenir facilement la température en degrés Fahrenheit ainsi que l'indice de chaleur utilisé aux États-Unis pour exprimer le degré d'inconfort causé par la combinaison de la chaleur et de l'humidité  (formules de Rothfusz et Steadman).

Sketch: température, humidité relative, point de rosée et humidex

Puisque je vis au Canada, c'est plutôt l'indice humidex qui m'intéresse. Et puisque l'humidex se calcule au moyen du point de rosée (température sous laquelle la vapeur d'eau contenue dans l'air se condense sur les surfaces), j'ai écrit un sketch qui affiche la température, l'humidité relative, le point de rosée et l'indice humidex.

Connaissant la température et l'humidité relative, la formule de Heinrich Gustav Magnus-Tetens permet de calculer le point de rosée:

J'ai d'abord calculé α(T,RH) à la ligne 48, dans une variable baptisée "alpha", puis je l'ai utilisée à la ligne 49 pour le calcul du point de rosée (variable "rosee").

Finalement, j'ai calculé l'indice humidex (ligne 52) grâce à l'équation mise au point par Masterton et Richardson:

Pour l'interprétation du résultat obtenu, j'ai utilisé la formulation exacte proposée par Environnement et changement climatique Canada.

Ce qui m'a donné ce résultat dans le moniteur série:

-

	/**********************************************************
	Affichage de l'humidité relative, de la température,
	du point de rosée et de l'indice humidex à partir des
	mesures d'un DHT22 branché à un Arduino Uno.
	Pour plus d'informations:
	https://electroniqueamateur.blogspot.com/2020/07/mesurer-la-temperature-et-lhumidite.html
	**********************************************************/
	// bibliothèque DHT d'Adafruit:
	#include <DHT.h>; // https://github.com/adafruit/DHT-sensor-library
	#define BrocheDHT 2 // capteur branché à la broche 2 de l'Arduino
	#define DHTTYPE DHT22 // pourrait aussi être DHT11, DHT12 ou DHT21
	DHT dht( BrocheDHT, DHTTYPE);
	void setup()
	{
	dht.begin();
	Serial.begin(9600);
	Serial.println("Capteur DHT22...On attend qu'il se stabilise");
	delay(3000);
	}
	void loop()
	{
	float humidite, temperature, alpha, rosee;
	int humidex;
	// lecture des mesures du capteur
	humidite = dht.readHumidity();
	temperature = dht.readTemperature();
	// on s'assure qu'une mesure a été prise
	if (isnan( humidite) || isnan( temperature)) {
	Serial.println("Le capteur n'a rien mesure! Est-il branche?");
	delay(3000);
	return;
	}
	// calcul du point de rosée (formule de Heinrich Gustav Magnus-Tetens)
	alpha = log(humidite / 100) + (17.27 * temperature) / (237.3 + temperature);
	rosee = (237.3 * alpha) / (17.27 - alpha);
	// calcul de l'indice humidex
	humidex = temperature + 0.5555 * (6.11 * exp(5417.753 * (1 / 273.16 - 1 / (273.15 + rosee))) - 10);
	Serial.print("Temperature: ");
	Serial.print(temperature);
	Serial.println( "°C");
	Serial.print("Humidite: ");
	Serial.print(humidite);
	Serial.println( "%");
	Serial.print("Point de rosee: ");
	Serial.print(rosee);
	Serial.println( "°C");
	Serial.print("Humidex: ");
	Serial.println(humidex);
	// interprétation de l'humidex
	if (humidex < 20) {
	Serial.println("(Pas d'inconfort)");
	}
	else if (humidex >= 20 && humidex < 30) {
	Serial.println("(Un peu d’inconfort)");
	}
	else if (humidex >= 30 && humidex < 40) {
	Serial.println("(Un certain inconfort)");
	}
	else if (humidex >= 40 && humidex < 45) {
	Serial.println("(Beaucoup d’inconfort : évitez les efforts)");
	}
	else {
	Serial.println("(Danger : coup de chaleur possible)");
	}
	Serial.println();
	Serial.println("-----------------------");
	Serial.println();
	delay(3000);
	}

view raw DHT22_humidex.ino hosted with ❤ by GitHub

-

À lire également:

Pour compléter vos mesures météorologiques, vous pouvez mesurer la pression atmosphérique avec un capteur BMP180 et fabriquer votre propre anémomètre.

Yves Pelletier (Twitter, Facebook)

Dans un blog près de chez vous...(12)

Quelques publications récentes sur des blogs en français. Bonne lecture!

RitonDuino

• Arduino : Stockage en Flash SPI
• Porte Motorisée de Poulailler (le bilan)
• INA138 et MAX4372 : Current Monitoring
• Un Module à 16 Mosfets

Arduiblog

• Air:bit, un micro:bit volant
• Utilisation du kit DaDa:bit

MCHobby

• Quelle résistance sur un Piezo Buzzer ? Et une diode aussi ?!?!
• PYBStick - Buzzer
• MicroPython: pilote pour l'horloge RTC PCF8523
• Clavier I2C pour application MicroContrôleur
• GameBoy - Ouverture et CPU (partie 1)
• GameBoy - Ouverture et CPU (partie 1a)
• Micropython - Pilote pour capteur SHT3X (SHT31-F) humidité / température

Le site "do it yourself" de Daniel

• Tuto sonde qualité de l’air

Framboise314

• Dupliquez la carte SD de votre Raspberry Pi avec rpi-clone
• Exploration de l’EEPROM HAT du Raspberry Pi (1ere partie)
• Exploration de l’EEPROM HAT du Raspberry Pi (2e partie)
• Créer sa carte HAT pour Raspberry Pi avec EasyEDA

Yves Pelletier (Twitter, Facebook)

ESP32-CAM: gestion à distance de la carte SD

J'ai déjà publié quelques projets consistant à enregistrer sur une carte microSD les photographies prises par un module ESP32-CAM (voir les articles enregistrement sur carte microSD et photographie time lapse). Un inconvénient de ces précédents projets, c'est que pour visionner les photos déjà enregistrées, il était nécessaire d'éjecter la carte afin de lire son contenu avec un autre appareil.

Je vous présente aujourd'hui une version améliorée dans laquelle une page web générée par l'ESP32-CAM nous offre la possibilité de voir le contenu de la carte microSD, et d'effacer les photos non-désirées à partir de n'importe quel appareil branché au même réseau WIFI.

La photo ci-dessous vous donne un aperçu de la page web.

On peut prendre une nouvelle photo en cliquant sur le bouton "Prendre une photo". Elle est immédiatement sauvegardée sur la carte SD.

La page présente également la liste des fichiers présents sur la carte microSD. Lorsqu'on clique sur le nom du fichier, la photo est affichée (vous pouvez la télécharger en utilisant le bouton droit de la souris).

Un bouton "Supprimer" permet d'effacer le fichier de la carte microSD.

Le sketch est basé en partie sur un exemple intitulé SDWebServer, qui était automatiquement installé lors de l'ajout de la carte ESP8266 dans l'IDE Arduino.

Afin d'utiliser le sketch ci-dessous, vous devez avoir installé dans l'IDE Arduino les extensions nécessaires à la programmation de la carte ESP32; les instructions détaillées sont ici. La façon de programmer l'ESP32-CAM avec l'IDE Arduino est expliquée en détail dans cet autre article.

Voici le sketch:

-

	/******************************************************************
	L'ESP32-CAM présente une page web qui permet de prendre des photos
	et de les enregistrer sur une carte SD, de visionner les photos
	déjà présentes sur la carte, et de supprimer les photos non-désirées.
	Pour plus d'informations:
	http://electroniqueamateur.blogspot.com/2020/07/esp32-cam-gestion-distance-de-la-carte.html
	******************************************************************/
	#include <WiFi.h>
	#include <WiFiClient.h>
	#include <WebServer.h>
	#include "FS.h" // manipulation de fichiers
	#include "SD_MMC.h" // carte SD
	#include "esp_camera.h" // caméra!
	// écrivez le nom et le mot de passe de votre réseau WIFI
	const char* ssid = "**********";
	const char* password = "**********";
	WebServer server(80);
	static bool cartePresente = false;
	int numero_fichier = 0; // numéro de la photo (nom du fichier)
	// prise de la photo et création du fichier jpeg
	void enregistrer_photo (void)
	{
	char adresse[20] = ""; // chemin d'accès du fichier .jpeg
	camera_fb_t * fb = NULL; // frame buffer
	// prise de la photo
	fb = esp_camera_fb_get();
	if (!fb) {
	Serial.println("Echec de la prise de photo.");
	return;
	}
	numero_fichier = numero_fichier + 1;
	// enregitrement du fichier sur la carte SD
	sprintf (adresse, "/%d.jpg", numero_fichier);
	fs::FS &fs = SD_MMC;
	File file = fs.open(adresse, FILE_WRITE);
	if (!file) {
	Serial.println("Echec lors de la creation du fichier.");
	}
	else {
	file.write(fb->buf, fb->len); // payload (image), payload length
	Serial.printf("Fichier enregistre: %s\n", adresse);
	}
	file.close();
	esp_camera_fb_return(fb);
	// on affiche un message de confirmation
	server.setContentLength(CONTENT_LENGTH_UNKNOWN);
	server.send(200, "text/html", "");
	WiFiClient client = server.client();
	server.sendContent("<h1>Une nouvelle photo a &eacute;t&eacute; prise.</h1>");
	server.sendContent("<p><a href = / > Retour &agrave; la liste des fichiers </a></p>");
	}
	void returnOK() {
	server.send(200, "text/plain", "");
	}
	void returnFail(String msg) {
	server.send(500, "text/plain", msg + "\r\n");
	}
	// Affichage d'un fichier présent sur la carte
	bool loadFromSdCard(String path) {
	String dataType = "text/plain";
	if (path == "/") {
	printDirectory();
	}
	else {
	if (path.endsWith(".src")) {
	path = path.substring(0, path.lastIndexOf("."));
	} else if (path.endsWith(".htm")) {
	dataType = "text/html";
	} else if (path.endsWith(".css")) {
	dataType = "text/css";
	} else if (path.endsWith(".js")) {
	dataType = "application/javascript";
	} else if (path.endsWith(".png")) {
	dataType = "image/png";
	} else if (path.endsWith(".gif")) {
	dataType = "image/gif";
	} else if (path.endsWith(".jpg")) {
	dataType = "image/jpeg";
	} else if (path.endsWith(".ico")) {
	dataType = "image/x-icon";
	} else if (path.endsWith(".xml")) {
	dataType = "text/xml";
	} else if (path.endsWith(".pdf")) {
	dataType = "application/pdf";
	} else if (path.endsWith(".zip")) {
	dataType = "application/zip";
	}
	fs::FS &fs = SD_MMC;
	File dataFile = fs.open(path.c_str());
	if (!dataFile) {
	return false;
	}
	if (server.hasArg("download")) {
	dataType = "application/octet-stream";
	}
	if (server.streamFile(dataFile, dataType) != dataFile.size()) {
	Serial.println("Sent less data than expected!");
	}
	dataFile.close();
	}
	return true;
	}
	// utilisé lors de la suppression d'un fichier
	void deleteRecursive(String path) {
	fs::FS &fs = SD_MMC;
	File file = fs.open((char *)path.c_str());
	if (!file.isDirectory()) {
	file.close();
	fs.remove((char *)path.c_str());
	return;
	}
	file.rewindDirectory();
	while (true) {
	File entry = file.openNextFile();
	if (!entry) {
	break;
	}
	String entryPath = path + "/" + entry.name();
	if (entry.isDirectory()) {
	entry.close();
	deleteRecursive(entryPath);
	} else {
	entry.close();
	fs.remove((char *)entryPath.c_str());
	}
	yield();
	}
	fs.rmdir((char *)path.c_str());
	file.close();
	}
	// suppression d'un fichier
	void handleDelete() {
	fs::FS &fs = SD_MMC;
	if (server.args() == 0) {
	return returnFail("Mauvais arguments?");
	}
	String path = server.arg(0);
	if (path == "/" || !fs.exists((char *)path.c_str())) {
	returnFail("BAD PATH");
	return;
	}
	deleteRecursive(path);
	// on affiche un message de confirmation
	server.setContentLength(CONTENT_LENGTH_UNKNOWN);
	server.send(200, "text/html", "");
	WiFiClient client = server.client();
	server.sendContent("<h1>Le fichier a &eacute;t&eacute; supprim&eacute;</h1>");
	server.sendContent("<p><a href = / > Retour &agrave; la liste des fichiers </a></p>");
	}
	// Affichage du contenu de la carte
	void printDirectory() {
	fs::FS &fs = SD_MMC;
	String path = "/";
	File dir = fs.open((char *)path.c_str());
	path = String();
	if (!dir.isDirectory()) {
	dir.close();
	return returnFail("PAS UN REPERTOIRE");
	}
	dir.rewindDirectory();
	server.setContentLength(CONTENT_LENGTH_UNKNOWN);
	server.send(200, "text/html", "");
	WiFiClient client = server.client();
	server.sendContent("<h1>Prise de photo</h1>");
	server.sendContent("<br> <form action='/clic' method='GET'> <INPUT type='submit' value='Prendre une photo'></form><br> ");
	server.sendContent("<h1>Contenu de la carte SD</h1>");
	for (int cnt = 0; true; ++cnt) {
	File entry = dir.openNextFile();
	if (!entry) {
	break;
	}
	String output;
	output += "<a href = ";
	output += entry.name();
	output += "> ";
	output += entry.name();
	// on ajoute un bouton delete:
	output += "</a> &nbsp; &nbsp; &nbsp; &nbsp; <a href = /delete?url=";
	output += entry.name();
	output += "> [Supprimer] </a> <br>";
	server.sendContent(output);
	entry.close();
	}
	dir.close();
	}
	// on tente d'afficher le fichier demandé. Sinon, message d'erreur
	void handleNotFound() {
	if (cartePresente && loadFromSdCard(server.uri())) {
	return;
	}
	String message = "Carte SD non detectee ou action imprevue\n\n";
	message += "URI: ";
	message += server.uri();
	message += "\nMethod: ";
	message += (server.method() == HTTP_GET) ? "GET" : "POST";
	message += "\nArguments: ";
	message += server.args();
	message += "\n";
	for (uint8_t i = 0; i < server.args(); i++) {
	message += " NAME:" + server.argName(i) + "\n VALUE:" + server.arg(i) + "\n";
	}
	server.send(404, "text/plain", message);
	Serial.print(message);
	}
	void setup(void) {
	// définition des broches de la caméra pour le modèle AI Thinker - ESP32-CAM
	camera_config_t config;
	config.ledc_channel = LEDC_CHANNEL_0;
	config.ledc_timer = LEDC_TIMER_0;
	config.pin_d0 = 5;
	config.pin_d1 = 18;
	config.pin_d2 = 19;
	config.pin_d3 = 21;
	config.pin_d4 = 36;
	config.pin_d5 = 39;
	config.pin_d6 = 34;
	config.pin_d7 = 35;
	config.pin_xclk = 0;
	config.pin_pclk = 22;
	config.pin_vsync = 25;
	config.pin_href = 23;
	config.pin_sscb_sda = 26;
	config.pin_sscb_scl = 27;
	config.pin_pwdn = 32;
	config.pin_reset = -1;
	config.xclk_freq_hz = 20000000;
	config.pixel_format = PIXFORMAT_JPEG; //YUV422|GRAYSCALE|RGB565|JPEG
	config.frame_size = FRAMESIZE_VGA; // QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
	config.jpeg_quality = 10; // 0-63 ; plus bas = meilleure qualité
	config.fb_count = 2; // nombre de frame buffers
	// initialisation de la caméra
	esp_err_t err = esp_camera_init(&config);
	if (err != ESP_OK) {
	Serial.printf("Echec de l'initialisation de la camera, erreur 0x%x", err);
	return;
	}
	sensor_t * s = esp_camera_sensor_get();
	// connexion au WIFI
	Serial.begin(115200);
	WiFi.mode(WIFI_STA);
	WiFi.begin(ssid, password);
	Serial.print("Connexion au reseau Wifi ");
	Serial.println(ssid);
	uint8_t i = 0;
	while (WiFi.status() != WL_CONNECTED && i++ < 20) {//wait 10 seconds
	delay(500);
	}
	if (i == 21) {
	Serial.print("Impossible de se connecter au reseau ");
	Serial.println(ssid);
	while (1) {
	delay(500);
	}
	}
	Serial.print("Connecte a l'adresse IP: ");
	Serial.println(WiFi.localIP());
	// initialisation du web server
	server.on("/delete", HTTP_GET, handleDelete);
	server.on("/clic", HTTP_GET, enregistrer_photo);
	server.onNotFound(handleNotFound);
	server.begin();
	Serial.println("Serveur HTTP en fonction.");
	// initialisation de la carte micro SD
	if (SD_MMC.begin()) {
	uint8_t cardType = SD_MMC.cardType();
	if (cardType != CARD_NONE) {
	Serial.println("Carte SD Initialisee.");
	cartePresente = true;
	}
	}
	}
	void loop(void) {
	server.handleClient();
	}

view raw ESP32-CAM_gestion_carte.ino hosted with ❤ by GitHub

-

Lors du démarrage du programme, l'adresse IP de l'ESP32-CAM s'affiche dans le moniteur série. Il s'agit de copier cette adresse dans un navigateur web pour atteindre la page web générée par l'ESP32-CAM.

À lire également:

Mes autres publications concernant l'ESP32-CAM:

• ESP32-CAM: Première utilisation avec l'IDE Arduino
• ESP32-CAM: un web server minimaliste
• ESP32-CAM: enregistrer des photos dans Google Drive
• ESP32-CAM: enregistrer des photos sur la carte microSD
• Time-lapse avec l'ESP32-CAM
• Mouvement panoramique avec ESP32-CAM et servomoteur
• Les LEDs de l'ESP32-CAM

Yves Pelletier (Twitter, Facebook)

Mesurer la pression atmosphérique avec BMP180 et micro:bit

Le capteur BMP180 a été spécialement conçu pour mesurer la pression atmosphérique ainsi que la température. Dans cet article, nous le branchons à une carte micro:bit qui pourra tout aussi bien être programmée avec MakeCode qu'avec MicroPython.  Afin de simplifier les choses au maximum, nous afficherons la pression atmosphérique (en hPa) et la température (en °C) sur la matrice de LEDs du micro:bit.

Connexions

Le capteur BMP180 communique ses mesures avec le protocole I²C. On le branche donc au micro:bit de la façon suivante:

• Broche VIN  du BMP180:   3 V du micro:bit

• Broche GND du BMP180: GND du micro:bit

• Broche SCL du BMP180: P19 du micro:bit

• Broche SDA du BMP180: P20 du micro:bit

Programmation avec MakeCode

Le programmation avec MakeCode est extrêmement simple si vous installez l'extension BMP180 par Shaoziyang: vous allez dans la section "Extensions", ce qui peut se faire en passant par la roue d'engrenage en haut à droite...

...et vous faites une recherche de "bmp180":

Une fois l'extension installée dans votre projet, vous disposez d'une nouvelle catégorie "BMP180", qui contient deux blocs "pressure" et "température".

Il s'agit d'insérer ces blocs dans votre programme chaque fois que vous désirez connaître la pression ou la température:

Programmation en MicroPython

Si vous préférez programmer en MicroPython, ce sera tout aussi facile puisque Shaoziyang, l'auteur de l'extension pour MakeCode, a également écrit une bibliothèque en MicroPython. Avec cette bibliothèque, la pression et la température s'obtiennent respectivement grâce aux méthodes Pressure() et Temperature(), comme dans l'exemple de script ci-dessous.

-

	'''
	Affichage de la pression et de la temperature
	mesurees par un BMP180 branche a un micro:bit
	Utilise la bibliotheque bmp180 par shaoziyang:
	https://github.com/shaoziyang/microbit-lib/tree/master/sensor/bmp180
	'''
	from microbit import *
	import bmp180
	capteur = bmp180.BMP180()
	while True:
	display.scroll("P:")
	display.scroll(str(capteur.Pressure()))
	display.scroll("T:")
	display.scroll(str(capteur.Temperature()))
	sleep(500)

view raw microbit_pression.py hosted with ❤ by GitHub

-

À lire aussi:

D'autres articles impliquant le micro:bit:

• Micro:Bit - Première exploration avec MakeCode
• Exploration de la carte micro:bit...deuxième volet
• Micro:bit et moteur pas à pas
• Mesurer une distance avec un HC-SR04 et un micro:bit

D'autres projets impliquant le capteur BMP180:

• Mesurer la pression atmosphérique avec BMP180 et Arduino
• Mesure de la pression dans un liquide avec BMP180 et Arduino
• Fabrication d'une flûte à bec MIDI (Arduino)
• Capteur de pression BMP180 et STM32 Nucleo (programmé avec mbed)

La carte micro:bit utilisée pour la rédaction de cet article a été fournie gratuitement par DigitSpace.

Yves Pelletier (Twitter, Facebook)

Capteur de champ magnétique à effet Hall KY-024

Le capteur à effet Hall KY-024 est un module qui permet de détecter la présence d'un champ magnétique, ou de mesurer son intensité.

Le capteur lui-même est situé du côté opposé aux broches de connexion (il a l'allure d'un petit transistor): il s'agit d'un SS49E; sa broche de sortie transmet une tension proportionnelle à l'intensité du champ magnétique.  Sa sensibilité à 25°C est typiquement de 1.4 mV/Gauss, mais elle varie d'un specimen à l'autre, donc celle de votre capteur peut aussi bien être de 1,0 mV/Gauss que de 1,75 mV/Gauss. Pour calculer un résultat précis en Gauss ou en Tesla, une calibration est donc nécessaire.

Le module comporte également un comparateur LM393 qui sert à produire un signal numérique indiquant si l'intensité du champ magnétique est inférieure ou supérieure à un certain seuil.

Le module KY-024 comporte 4 connecteurs: AO, G, + et DO.

• La broche AO (Analog Out) est la sortie analogique qui transmet la mesure du champ magnétique. Lorsque le champ magnétique est nul, sa tension est égale à la moitié de la tension d'alimentation du module (donc 2,5 V si vous alimentez le module avec une tension de 5 V, 1,65 V si vous alimentez le module avec une tension de 3,3 V).  En présence d'un champ magnétique, la tension augmente ou diminue selon la direction du champ. La sortie AO est pertinente si vous désirez mesurer un champ magnétique, ou observer comment il varie dans le temps. Pour l'utiliser, vous devez la brancher à une entrée analogique d'un microcontrôleur (ou même à un simple voltmètre, si le champ magnétique ne varie pas trop rapidement).

• La broche G (Ground) doit être branchée à la masse (broche GND du microcontrôleur, ou la borne négative de la source d'alimentation).

• La broche + doit être alimentée avec une tension de 3,3 V ou 5 V. Puisque la tension de sortie du module dépend de cette alimentation, il est important de choisir 3,3 V si vous utilisez un microcontrôleur fonctionnant à un niveau logique de 3,3 V (exemples: ESP8266,  STM32, Raspberry Pi...) alors qu'une tension de 5 V sera réservée aux microcontrôleurs qui fonctionnent à un niveau logique de 5 V (exemple: Arduino Uno).

• La broche DO (digital Out) sera utilisée pour détecter la présence d'un champ magnétique (pour un compte-tours, par exemple). Cette sortie génère un signal numérique BAS en l'absence de champ magnétique, et HAUT en présence d'un champ magnétique. La sensibilité du capteur peut être ajustée au moyen du potentiomètre intégré au module (une rotation en sens horaire permet de réagir à des champs plus faibles). La LED située près du potentiomètre s'allume lorsque le signal est haut, ce qui facilite l'ajustement du potentiomètre.

Sur la photographie ci-dessous, la LED s'allume lorsqu'on approche l'aimant.

Mise à l'essai

Pour observer le comportement des deux sorties du module KY-024, j'ai branché la broche AO du module à l'entrée A0 d'un Arduino Uno, et j'ai branché la broche DO du module à l'entrée 7 de l'Arduino Uno. Un petit aimant était placé à différentes distances du capteur.

Le sketch est minimaliste: j'affiche dans le moniteur série la valeur analogique lue à l'entrée A0 et la valeur numérique lue à l'entrée 7.

En absence de champ magnétique, mon module a affiché une valeur analogique de 517 et un niveau logique bas.

J'ai approché un aimant: la valeur analogique a augmenté, alors que le signal numérique est demeuré bas.

J'ai inversé l'aimant, et l'ai approché de nouveau. Cette fois, la valeur analogique diminue, et le signal logique devient haut quand le signal analogique atteint environ 485.

Contrairement à ce que j'aurais pensé,  le potentiomètre affecte le signal analogique. Par exemple, après avoir tourné le potentiomètre dans le sens antihoraire, la valeur mesurée en absence de champ magnétique est d'environ 525...

...et la valeur de transition du signal numérique semble sensiblement la même qu'auparavant, mais elle correspond à un champ magnétique plus intense (l'aimant devait être plus proche du capteur).

À lire également:

D'autres façons de détecter ou de mesurer un champ magnétique:

• Interrupteur Reed (résultat similaire à la sortie DO du KY-024)
• Sonde à effet Hall Allegro A1302 (résultat similaire à la sortie AO du KY-024)
• Magnétomètre HMC5883L (fournit la composante du champ selon 3 axes)

Yves Pelletier (Twitter, Facebook)