lundi 23 mars 2020

Arduino caméléon


Je me permets aujourd'hui de revisiter un mini-projet amorcé en 2014: l'utilisation d'une sonde RGB pour analyser, par réflexion, la couleur d'une surface. À l'époque, j'avais tenté (avec plus ou moins de succès) de nommer la couleur analysée. Dans cette nouvelle version, je tente (avec plus ou moins de succès) de reproduire la couleur analysée sur un écran couleur (ST7735) branché à l'Arduino.  L'écran affiche du rouge lorsque la sonde est placée sur une surface rouge, alors qu'il affiche du bleu lorsque la sonde est placée sur une surface bleue, etc.

La vidéo ci-dessous montre l'utilisation du dispositif: au démarrage du programme, on doit placer la sonde sur une surface blanche, puis sur une surface noire, afin de calibrer l'appareil. L'écran prend ensuite une couleur qui, sans être identique,  s'approche de celle de la surface sur laquelle on a placé la sonde.




La sonde RGB: principe de fonctionnement

La sonde RGB (red-green-blue) est constituée d'une LED RGB et d'une photorésistance (la LED RGB peut être remplacée par 3 LEDs: une rouge, une verte et une bleue).

Le dispositif fonctionne par réflexion: la LED émet d'abord une lumière rouge sur la surface à analyser. La lumière réfléchie est captée par la photorésistance.

La LED émet ensuite une lumière verte, et la photorésistance mesure la réflexion.  Finalement, la LED émet une lumière bleue, et la photorésistance mesure à nouveau la réflexion.

Une surface de couleur rouge va fortement réfléchir le rouge, alors que le vert et le bleu seront plutôt absorbés (donc faiblement réfléchis). Le vert réfléchit surtout la lumière verte, le bleu réfléchit surtout la lumière bleue, le blanc réfléchit toutes les couleurs alors que le noir les absorbe toutes, etc.

D'une certaine façon, on peut considérer notre sonde RGB comme une caméra numérique rudimentaire...à un seul pixel.

Fabrication de la sonde RGB

Parlons d'abord de la source de lumière: la LED RGB. Il s'agit en fait de 3 LEDs (une rouge, une verte et une bleue) réunies dans un même dispositif. J'ai utilisé un modèle à cathode commune (une broche "-" commune aux 3 LEDs pour la sortie du courant). La broche commune est celle qui est la plus longue.

Puisque notre analyse repose sur la lumière réfléchie par la surface colorée, il est important que notre LED émette une lumière assez intense. La tension de la LED rouge (environ 2 V) étant plus faible que la tension des deux autres LEDs (environ 3 V) j'ai associé la LED rouge à une résistance de 150 Ω, et les deux autres à une résistance de 100 Ω (il en résulte un courant d'environ 20 mA pour une tension de 5 V). La LED RGB a été branché aux sorties 2 (rouge), 3 (vert) et 4 (bleu) de l'Arduino.



Votre photorésistance sera associée à une résistance dont la valeur maximisera autant que possible l'écart entre les différentes valeurs mesurées. Pour trouver cette valeur, vous pouvez mesurer avec un multimètre la résistance de la photorésistance lorsque la LED éclaire une surface blanche (Rmin), et sa résistance lorsque la LED éclaire une surface noire (Rmax). La valeur optimale de la résistance à relier en série avec la photorésistance se calcule de cette façon:

      Rfixe = (Rmin * Rmax)1/2

Ceci étant dit, la valeur exacte de cette résistance n'est pas tellement importante, pourvu qu'elle soit du même ordre de grandeur que la résistance moyenne de votre photorésistance. La valeur de la photorésistance sera mesurée à l'entrée A0 de l'Arduino.

L'ensemble du circuit constitué de la LED et de la photorésistance est enfermé dans un petit récipient opaque, ouvert à une extrémité,  dont la surface intérieure est peinte en noir. Un obstacle opaque doit empêcher la lumière émise par la LED d'atteindre directement la photorésistance (on veut que la photorésistance capte uniquement la lumière réfléchie par la surface colorée).



Connexions de l'écran et installation de la bibliothèque

Je vous réfère à ce précédent article "Écran couleur KMR-1.8 SPI (ST7735) et Arduino" pour les instructions sur les connexions de l'écran à l'Arduino, le téléchargement de la bibliothèque de Bodmer et la configuration de cette bibliothèque.

Un autre modèle d'écran couleur peut évidemment être utilisé, ce qui pourrait vous obliger à le brancher différemment et à apporter certaines modifications au sketch ci-dessous.

Sélection de la couleur à l'écran: le système RGB 565

Ces écrans utilisent un système de couleur à 16 bits appelé "RGB 565": les 5 premiers bits (de poids fort) sont utilisés pour le dosage de rouge, les 6 bits suivants décrivent le vert, et les 5 derniers bits (de poids faible) décrivent le bleu.

Ainsi, le nombre binaire 1111100000000000 représente du rouge pur, sans vert ni bleu.
Le nombre binaire 0000011111100000 représente du vert pur, sans rouge ni bleu.
Le nombre binaire 0000000000011111 représente du bleu pur, sans rouge ni vert.

Les 5 bits qui qualifient le rouge et le bleu permettent donc 32 niveaux d'intensité différents (0 à 31), alors que les 6 bits qui qualifient le vert permettent 64 niveaux différents (0 à 63).

Le sketch

Au démarrage du programme (setup), on lit la valeur de la photorésistance lorsqu'on éclaire une surface blanche (toutes les couleurs réfléchies au maximum), puis une surface noire (toutes les couleurs réfléchies au minimum).

Pendant le reste du programme (loop), la valeur de la photorésistance est lue périodiquement, et convertie (fonction "map") de façon à être étalée entre 0 et 31 (pour le rouge et le bleu) et entre 0 et 63 (pour le vert).

Les valeurs représentant le rouge, le vert et le bleu sont ensuite combinées en une seule variable de 16 bits (la variable "couleur").

-

-

Résultats

Je dois malheureusement admettre que les résultats sont mitigés. L'écran prend effectivement une teinte rougeâtre si la sonde se trouve sur une surface rouge, une teinte verdâtre lorsque la sonde se trouve sur une surface verte, et une teinte bleuâtre lorsque la sonde se trouve sur une surface bleue...à la condition que la surface soit mate et de couleur très vive.

Mais pour le reste, les choses se compliquent: une surface de couleur orangée ne donnera probablement pas un écran orange. Avec un peu de chance, le jaune peut sortir en jaune-vert, mais il peut aussi donner du vert, ou encore du blanc...

Notre sonde RGB semble trop rudimentaire; la relation entre l'intensité lumineuse et la tension mesurée à l'entrée A0 n'est probablement pas linéaire.

Je serais curieux de répéter l'expérience avec un capteur de couleur plus sophistiqué, comme le TCS3200 (j'en ai commandé un ... à suivre).

Yves Pelletier (TwitterFacebook)


dimanche 22 mars 2020

Dans un blog près de chez vous (9)




RitonDuino:

Framboise 314:

Les carnets de Byfeel:

Framboise au potager:

Arduiblog:

SLmédiation:

Yves Pelletier (TwitterFacebook)

dimanche 15 mars 2020

Time-lapse avec l'ESP32-CAM

La technique du time-lapse consiste à produire une vidéo ultra-accélérée au moyen de photographies prises sur une longue période de temps.

J'ai apporté quelques modifications à mes sketches précédents afin de produire des vidéos time-lapse au moyen de mon ESP32-CAM (programmée avec l'IDE Arduino, comme d'habitude).

Comme dans mes projets précédents, l'image captée par la caméra est présentée en temps réel sur une page web. Mais cette page comporte, en plus, un champ texte permettant à l'utilisateur d'écrire le nombre de secondes désiré entre deux images consécutives ainsi qu'un bouton permettant de démarrer et d'interrompre l'enregistrement des images.


Les images sont enregistrées en format jpeg sur une carte micro-SD insérée dans l'ESP32-CAM. On peut ensuite combiner ces images pour en faire une vidéo (pour réaliser la vidéo ci-dessous, j'ai utilisé Movie Maker).





Sketch

Mon point de départ à été mon sketch qui enregistre des photos sur une carte microSD.

Les principales modifications sont:
  • dans la routine web_handler(), aux lignes 127 à 134: ajout d'un champ de texte pour choisir le nombre de secondes entre 2 images successives.
  • dans la routine clic_handler(), aux lignes 189 à 225: récupération du délai entré par l'utilisateur, et activation (ou désactivation) de l'enregistrement des photos.
  • dans la routine loop(), aux lignes 360 à 365: vérification si c'est le moment de prendre une photo, compte tenu du délai choisi par l'utilisateur.
-
-

À lire également

Dans le passé, j'avais fait du time-lapse avec un vieil appareil photo numérique commandé par un Arduino (on peut aussi utiliser la camera du Raspberry Pi, mais je n'ai pas écrit d'article sur ce sujet spécifique).

De plus, j'ai publié plusieurs articles concernant l'ESP32-CAM: première utilisation,  un web server minimaliste , enregistrer des photos sur la carte microSDles LEDs de l'ESP32-CAM, mouvement panoramique de l'ESP32-CAM avec un servomoteur.

Yves Pelletier (TwitterFacebook)

mardi 3 mars 2020

On joue à "Pong" avec la STM32 Blue Pill

Aujourd'hui, on joue au tennis! Notre adversaire: une carte STM32 Blue Pill (STM32F103C8T6) programmée au moyen de l'IDE Arduino.

Pour recréer cette variante du classique jeu d'arcade "Pong", j'ai utilisé, en plus de la blue pill, un écran OLED I2C SH1106 et un potentiomètre. J'ai choisi la blue pill, mais il ne devrait pas être très difficile de modifier le sketch afin de l'utiliser sur une autre carte supportée par l'IDE Arduino. De plus, grâce à la bibliothèque u8g2, le sketch peut être modifié pour utilisation avec un autre modèle d'écran monochrome.

Déroulement du jeu

L'utilisateur contrôle la "raquette" de gauche au moyen du potentiomètre. La raquette de droite est contrôlée par notre programme.



Installation de la bibliothèque u8g2

Afin de programmer la carte blue pill avec l'IDE Arduino, les fichiers relatifs aux cartes STM32 doivent avoir préalablement été installés au moyen du gestionnaire de fichier (voir ce précédent billet pour des instructions détaillées).

De plus, notre sketch utilisera la bibliothèque u8g2 pour contrôler l'écran OLED. Cette bibliothèque peut être installée grâce au gestionnaire de bibliothèques de l'IDE.

Circuit

Puisque l'écran OLED SH1106 est un périphérique  I2C, il est branché à la carte blue pill de la façon suivante:

  • Broche GND de l'écran OLED: broche GND de la blue pill
  • Broche VCC de l'écran OLED: broche 3.3 de la blue pill
  • Broche SCL de l'écran OLED: broche B6 de la blue pill
  • Broche SDA de l'écran OLED: broche B7 de la blue pill

Le potentiomètre est branché à la broche B0 de la blue pill, de façon à faire varier la tension entre 0 et 3,3 V.



Sketch

La routine "hasard" (ligne 36) est appelée chaque fois que la balle est remise en jeu (au tout début, et chaque fois qu'un point a été compté). Elle génère, de façon aléatoire, la hauteur initiale de la balle sur l'écran, et la vitesse à laquelle la balle se déplace (2 ou 3 pixels par cycle vers la gauche ou vers la droite, 2 ou 3 pixels par cycle vers le haut ou vers le bas). La raquette de l'adversaire est initialement placée à une hauteur similaire à celle de la balle, mais avec une imprécision aléatoire (ligne 41).

J'ai réglé la résolution du convertisseur analogique-numérique de la blue pill à 6 bits (ligne 59): le potentiomètre génère ainsi une valeur pouvant varier entre 0 et 63, ce qui correspond parfaitement aux 64 pixels de l'écran.

La raquette de l'adversaire tente de se maintenir à la même hauteur que la balle, mais il y parvient avec un taux de succès de 90% (ligne 75): l'adversaire n'est donc pas infaillible et le joueur peut gagner s'il réussit plusieurs coups consécutifs.

Dans sa version actuelle, le jeu ne s'arrête jamais!

- -

Yves Pelletier (TwitterFacebook)

dimanche 23 février 2020

Livre: Python pour la carte micro:bit par Julien Launay

Python pour la carte micro:bit
par Julien Launay
Éditions Eyrolles, 2019
Collection Serial makers
168 pages


Les éditions Eyrolles nous proposent un nouveau livre consacré à la carte micro:bit, cette petite carte programmable conçue au départ pour être utilisée dans les écoles britanniques. Mais alors que les autres livres que j'ai eu l'occasion de consulter (40 activités avec la carte micro:bit et Petits robots à fabriquer) préconisent l'utilisation de l'environnement graphique Makecode, celui-ci propose d'apprendre à programmer la micro:bit en langage Python.

Après une brève présentation de la carte micro:bit et de quelques environnements de développement qui peuvent être utilisés pour la programmer, le contenu du livre se divise en 3 grandes sections:

1)  Les bases en MicroPython. Cette section s'adresse au lecteur qui n'a jamais eu l'occasion de programmer en langage Python auparavant. On y présente la syntaxe de base du langage (variables, conditions, boucles...), mais rien de spécifique à la carte micro:bit.

2) Applications simples avec la carte micro:bit. Dans cette deuxième partie, on explique comment utiliser les différents capteurs et actionneurs intégrés à la carte: la matrice de LEDs, les boutons, le capteur de température, l'accéléromètre, la boussole, les entrées et les sorties (mesure d'un signal logique ou analogique, production d'un signal logique ou PWM), la communication entre deux cartes (grâce au module radio ou à une connexion filaire) ...

3) Applications avancées avec la carte micro:bit. On termine avec quelques projets qui nécessitent l'utilisation de cartes d'extension: on mentionne la carte d'extension Shield Grove, la carte CODO, la carte pour servomoteurs et LED de Kitronik, le capteur à ultrasons Grove 2.0.

Les principes de base sont explorés à travers des applications concrètes:  jeu de "tir à la corde" virtuel, dé à jouer électronique, boussole, lampe contrôlable à distance, robot éviteur d'obstacle, robot contrôlé à distance, etc. Les codes complets sont fournis, mais ils sont accompagnés d'un algorithme en français, le but de l'auteur étant de bien faire comprendre les concepts.

Puisqu'on utilise essentiellement les capteurs et actuateurs déjà présents sur la carte (ou encore des cartes d'extensions prêtes à l'emploi), il s'agit d'abord et avant tout d'un livre d'informatique, avec assez peu d'électronique (il n'y a pas de circuits à monter).

Même si le public cible est visiblement le milieu scolaire, les dilettantes devraient y trouver leur compte également (en particulier ceux qui n'ont aucune expérience en programmation).

À lire également

Des commentaires sur d'autres livres traitant d'électronique.

Yves Pelletier (TwitterFacebook)

mercredi 12 février 2020

Mouvement panoramique avec ESP32-CAM et servomoteur


Je continue de bien m'amuser avec l'ESP32-CAM. Cette fois, j'ai installé la caméra sur un servomoteur afin qu'elle puisse effectuer un mouvement panoramique horizontal­. J'ai ainsi obtenu une caméra de surveillance qui balaie un champ de vision beaucoup plus large.

À cette étape du projet, le servomoteur tourne en continu aussitôt qu'un utilisateur visionne l'image vidéo diffusée par le web server de l'ESP32-CAM. Il sera certainement intéressant, comme développement ultérieur, d'ajouter un deuxième servomoteur ainsi que des boutons de contrôle sur la page web, ce qui permettrait à l'utilisateur de positionner la caméra à distance (pan & tilt).

Connexions

J'ai branché le servomoteur à la broche GPIO 2 de l'ESP32-CAM.

Pour l'exécution d'un sketch simple dans lequel l'ESP32-CAM ne faisait rien d'autre que faire tourner le servomoteur, j'ai pu alimenter le servomoteur en le branchant à la même alimentation 5 V que l'ESP32-CAM. Mais aussitôt que j'essayais de brancher l'ESP32-CAM au réseau WiFi, le "brownout detector" interrompait le programme au démarrage. Pour cette raison, j'ai alimenté le servomoteur avec une alimentation 5 V distincte.


Test du servomoteur

Il y a quelques mois, j'avais exploré la production d'un signal PWM avec un ESP32; ça m'a facilité la tâche pour produire ce sketch qui ne fait rien d'autre que faire tourner le servomoteur dans un sens, puis dans l'autre. Dans mon cas, le servomoteur atteignait ses positions extrêmes pour un rapport cyclique d'environ 3550 et 8000, mais ces valeurs peuvent varier un peu d'un servomoteur à l'autre.

-
-

Sketch: web server avec mouvement panoramique

Voici finalement le sketch qui permet d'observer l'image vidéo sur un navigateur web. Il s'agit essentiellement de mon sketch de web server de base, auquel j'ai ajouté quelques lignes pour gérer le servomoteur.

Aux lignes 29 à 36, je définis quelques constantes (broche à laquelle le servomoteur est connecté, position minimale désirée, position maximale désirée, vitesse désirée) et deux variables globales: la position du servomoteur et la direction dans laquelle il tourne.


Aux lignes 223 à 225, j'initialise le signal PWM et l'assigne à la broche à laquelle j'ai branché le servomoteur.


La position du servomoteur est réglée à la ligne 103. Les lignes suivantes calculent la prochaine position et vérifient s'il est temps d'inverser le sens de rotation..



La vidéo ci-dessous montre le résultat. Le mouvement du servomoteur n'est pas parfaitement régulier (il semble ralentir à certains moments) et le support en papier que j'ai bricolé pour ma ESP32-CAM manque de rigidité (il se déforme un peu pendant la rotation, ce qui ajoute une oscillation verticale à l'image). Mais comme prototype, ça me semble assez bien.




-
-

À lire également:

Première utilisation de l'ESP32-CAM avec l'IDE Arduino , un web server minimaliste , enregistrer des photos sur la carte microSD, les LEDs de l'ESP32-CAM, time-lapse avec l'ESP32-CAM.

Yves Pelletier (TwitterFacebook)

mardi 11 février 2020

Dans un blog près de chez vous (8)


Ce dont on parle dans d'autres blogs...

RitonDuino:

Arduiblog:

Framboise 314:

Les carnets de Byfeel:

IDEHack:

Papsoid:

Raspberry Pi FR:

Yves Pelletier (TwitterFacebook)

vendredi 7 février 2020

Les LEDs de l'ESP32-CAM

Les modules ESP32_CAM de type "AI Thinker" comportent deux LEDs: une LED blanche de forte intensité située à l'avant de la caméra, et une LED rouge située à l'arrière.

La LED blanche est liée à la broche GPIO 4. Elle semble avoir été mise en place pour éclairer le sujet que vous photographiez ou filmez, si la lumière ambiante est insuffisante. Si vous désirez plutôt l'utiliser comme LED indicatrice, il sera très pertinent de réduire son intensité en l'alimentant par un signal PWM. Puisque la broche GPIO 4 est également liée au lecteur de carte microSD, la LED blanche s'allume inutilement chaque fois que des données sont enregistrées sur la carte, au grand désespoir de plusieurs utilisateurs.


La LED rouge est branchée à la broche GPIO 33.  Elle est allumée quand la broche GPIO 33 est au niveau logique bas, et éteinte quand elle est au niveau logique haut.



Voici, en guise de démonstration , un court sketch qui fait clignoter par alternance les deux LEDs de l'ESP32-CAM. Remarquez que pour allumer la LED blanche avec une intensité pas trop irritante, j'ai réglé le rapport cyclique du signal PWM a un niveau incroyablement faible.

-
-

À lire également:

Première utilisation de l'ESP32-CAM avec l'IDE Arduino , un web server minimaliste , enregistrer des photos sur la carte microSD, time-lapse avec l'ESP32-CAM, mouvement panoramique (ESP32-CAM et servomoteur).


Yves Pelletier (TwitterFacebook)

samedi 1 février 2020

ESP32-CAM: enregistrer des photos sur la carte microSD

Je vous propose aujourd'hui une version légèrement remaniée du web server que je vous présentais la semaine dernière: la page web générée par l'ESP32-CAM comporte maintenant un bouton qui permet d'enregistrer l'image sous la forme d'un fichier jpeg dans la carte microSD insérée dans l'ESP32-CAM. L'ESP32-CAM devient ainsi un appareil photo pouvant être déclenché à distance par WiFi.

Nous programmons l'ESP32-CAM avec l'IDE Arduino (voir ce précédent article pour plus de détails).

Pour utiliser le lecteur de cartes microSD de l'ESP32-CAM, l'inclusion des fichiers d'entête "FS.h" et "SD_MMC.h" est nécessaire.


J'ai défini deux variables globales: "carte_presente", qui prendra la valeur "1" si une carte microSD est détectée au démarrage du programme, et "numero_fichier", qui sera utilisée pour numéroter les photos. Dans ce programme, numero_fichier prend la même valeur à chaque redémarrage de la caméra: dans une future version, on pourrait conserver le dernier numéro en EEPROM pour éviter d'effacer une photo déjà présente sur la carte SD.


Dans setUp(), quelques lignes sont consacrées à l'initialisation de la carte.


Dans web_handler(), si une carte SD a été détectée, on ajoute à la page web un bouton qui permettra la prise de la photo. Sinon, on affiche plutôt un court message indiquant l'absence de carte SD.


L'enregistrement du fichier jpeg s'effectue à l'intérieur de la routine enregistrer_photo().


Utilisation

Lors du démarrage, l'adresse IP de la page web est affichée dans le moniteur série.



On copie l'adresse dans un navigateur web: une page web affiche l'image vidéo ainsi que le bouton "Photo".



Chaque clic sur le bouton "photo" génère un nouveau fichier jpeg sur la carte microSD.



Si aucune carte n'a été détectée, la page web présente quand même l'image vidéo, mais elle indique qu'aucune carte microSD n'est présente.




Sketch

Voici le sketch complet:

-
-

À lire également:

Première utilisation de l'ESP32-CAM avec l'IDE Arduino , un web server minimalisteles LEDs de l'ESP32-CAM, time-lapse avec l'ESP32-CAM, mouvement panoramique (ESP32-CAM et servomoteur).


Yves Pelletier (TwitterFacebook)

mercredi 29 janvier 2020

ESP32-CAM: un web server minimaliste


Lors du premier essai de ma ESP32-CAM, j'ai utilisé l'exemple officiel "CameraWebServer", conçu par l'équipe d'Espressif et fourni avec l'IDE Arduino.

Cet exemple a visiblement été créé pour en mettre plein la vue: il créé une page web sophistiquée qui comporte une grande quantité de boutons et de glissières permettant à l'utilisateur de régler tous les paramètres de l'image, d'activer la reconnaissance faciale, etc.  Il s'agit d'un programme assez complexe (1400 lignes de code réparties en 4 fichiers) et souvent nébuleux (les commentaires sont rares!).

Lorsque j'ai voulu apporter quelques modifications à la page web générée par cet exemple, j'ai eu la surprise de constater que son code html a été compressé (gzip) et présenté par une longue suite d'octets dans le fichier camera_index.h: vraiment pas pratique si vous désirez apporter des modifications!


Owen (alias easytarget) a apporté une solution à ce problème: dans sa version améliorée de l'exemple CameraWebServer, le code html de la page web est directement accessible dans le fichier "camera_index_ov2640.h": c'est beaucoup plus facile de comprendre comment la page web est générée, et d'y apporter des modifications. Owen a pris soin de préserver toutes les fonctionnalités de l'exemple officiel, et en a même ajouté quelques-unes (contrôle du flash et de la LED indicatrice, par exemple).

La version easytarget est donc devenue mon nouveau point de départ. Mais le programme demeure lourd: qu'est-ce qui fait quoi, exactement? Pas facile de s'y retrouver.

Je me suis donc donné comme mission de produire un sketch qui ne fera qu'une seule chose: afficher dans une page web l'image vidéo de l'ESP32-CAM. Ça a donné le sketch de 225 lignes présenté ci-dessous.

Le sketch

Dans ma version simplifiée, la page web générée par l'ESP32-CAM ne présente rien d'autre que l'image vidéo: l'utilisateur ne dispose d'aucun bouton qui lui permettrait de modifier le contraste, la luminosité, etc.

Je me suis également permis, très égoïstement de ne conserver que ce qui concerne le modèle d'ESP32-CAM que je possède (AI Thinker). Certaines modifications devront être apportées au sketch si vous désirez l'utiliser sur un autre modèle.

La routine "stream_handler()" s'occupe du "stream server": elle gère l'affichage en direct de l'image vidéo. La version officielle comportait certaines instructions liées à la reconnaissance faciale, qui ont été retirées.

La routine "web_handler()" construit la page web. Cette modeste page web est logée dans un tableau de 175 caractères.

La routine "startCameraServer()" démarre le web server et le stream server.

setUp() initialise la caméra et établit la connexion au réseau WiFi, et loop() n'a rien à faire puisque tout sera géré par stream_handler() et web_handler().

-
-

Utilisation

Au démarrage, l'adresse IP de la caméra est affichée dans le moniteur série.


On colle cette adresse dans un navigateur web pour accéder en direct à la vidéo.



À lire également

Première utilisation de l'ESP32-CAM avec l'IDE Arduino ,  enregistrer des photos sur la carte microSD, time-lapse avec l'ESP32-CAMles LEDs de l'ESP32-CAM, mouvement panoramique avec servomoteur.

Yves Pelletier (TwitterFacebook)


dimanche 26 janvier 2020

Robot Raspberry Pi


Le robot que nous allons assembler dans ce tutoriel est une plate-forme mobile dont le mouvement est contrôlé par un Rasbperry Pi. Pour l'instant, le robot ne comportera pas de capteurs qui lui permettraient de prendre des décisions de façon autonome: il sera plutôt contrôlé par des commandes  que nous lui procurerons par SSH à partir d'un autre ordinateur ou d'un téléphone. Bien entendu, des capteurs pourront être ajoutés au robot dans une étape subséquente.

 Matériel
  • Un Raspberry Pi capable de communiquer en WiFi. N'importe quel modèle fera l'affaire, j'en ai même profité pour mettre à contribution mon antique Raspberry Pi 1 modèle B (muni d'une petite clé WiFi). Il faut que la communication SSH soit activée dans le logiciel "Configuration du Raspberry Pi".


  • Une plate-forme mobile munie de deux roues, chaque roue étant contrôlée par son propre moteur à courant continu. C'est relativement facile de s'en procurer une toute faite. Si vous préférez la construire vous-même, assurez-vous d'utiliser des moteurs munis d'une boîte d'engrenages, sinon les roues tourneront beaucoup trop vite.

  • Un pilote de moteur: il s'agit d'un petit circuit qui sert d'intermédiaire entre le Raspberry Pi et les moteurs, car le courant nécessaire pour faire tourner un moteur est beaucoup trop intense pour les délicates broches GPIO du Raspberry Pi. Dans ce tuto, j'utilise le module L298N photographié ci-contre, mais il existe plusieurs autres possibilités­. Si vous préférez utiliser le L293D, par exemple, vous trouverez des informations utiles dans cet article concernant le contrôle de moteurs à courant continu avec un Rasperry Pi. Le script en python fourni un peu plus loin dans le présent billet devrait fonctionner correctement peu importe le pilote de moteur que vous utiliserez.
  • Une source d'alimentation pour le Raspberry Pi. J'ai utilisé un chargeur mobile pour téléphone ("USB power bank") qui a rempli son rôle à la perfection. 

  • Une source d'alimentation pour les moteurs: on évite bien des problèmes potentiels en utilisant une source d'alimentation dédiée aux moteurs, distincte de celle qui alimente le Raspberry Pi. Pour mes tests, j'ai utilisé un accumulateur NiMH de 9 V, qui n'est certainement pas le meilleur choix (avec sa capacité de 175 mAh, mon robot n'ira pas très loin). Une batterie LiPo ou Li-Ion de 7,4 V ou 6 piles de format AA auraient été des choix plus appropriés.
Schéma du circuit

Le module L298N comporte des broches d'alimentations (GND et +12), 6 entrées qui permettent au Raspberry Pi de contrôler les moteurs (ENA, IN1, IN2, IN3, IN4, ENB), et 4 sorties vers les moteurs (OUT1, OUT2, OUT3, OUT4). Il y a également une sortie 5 V, que je n'ai pas utilisée.
  • Broche +12 du L298N: Borne positive de l'alimentation des moteurs (12 V est un maximum).
  • Broche GND du L298N: Borne négative de l'alimentation des moteurs et une broche GND du Raspberry Pi.
  • OUT1 et OUT2 du L298N branchées à un des moteurs.
  • OUT3 et OUT4 du L298N branchées à l'autre moteur
  • ENA du L298N broche BCM 25 (BOARD 22) du Raspberry Pi
  • IN1 du L298N  broche BCM 23 (BOARD 16) du Raspberry Pi
  • IN2 du L298N broche BCM 12 (BOARD 18) du Raspberry Pi
  • IN3 du L298N broche BCM 10 (BOARD 19) du Raspberry Pi
  • IN4 du L298N broche BCM 9 (BOARD 21) du Raspberry Pi
  • ENB du L298N broche BCM 11 (BOARD 23) du Raspberry Pi


Script en Python

Pour contrôler le robot, j'ai installé dans le Raspberry Pi le script en Python ci-dessous, et je l'ai exécuté par SSH au moyen d'un téléphone ou d'un autre ordinateur.

Les commandes sont des chiffres de 0 à 9, dont la disposition respecte une certaine logique si vous utilisez un pavé numérique:
    numeric-keypad
  • 5: Arrêt. Les deux moteurs sont à l'arrêt (broche "enable" au niveau logique bas).
  • 8: Marche avant en ligne droite: les deux moteurs tournent dans le même sens.
  • 2: Marche arrière en ligne droite: les deux moteurs tournent dans le même sens.
  • 4: Rotation vers la gauche: les deux moteurs tournent en sens contraire
  • 6: Rotation vers la droite: les deux moteurs tournent en sens contraire
  • 7: Virage à gauche en avançant: le moteur de droite tourne, mais pas celui de gauche
  • 9: Virage à droite en avançant: le moteur de gauche tourne, mais pas celui de droite
  • 1: Virage à gauche en reculant: le moteur de droite tourne, mais pas celui de gauche
  • 3: Virage à droite en reculant: le moteur de gauche tourne, mais pas celui de droite
  • 0: Arrêt du programme
-
-


Pour terminer, une courte vidéo du véhicule en action:



À lire également:

En utilisant un Arduino plutôt qu'un Raspberry Pi, j'avais fait un robot qui se déplace selon une trajectoire pré-programmée, un robot téléguidé, un robot suiveur de ligne, un robot éviteur d'obstacles...


Yves Pelletier (TwitterFacebook)

samedi 18 janvier 2020

ESP32-CAM: première utilisation avec l'IDE Arduino


L'ESP32-CAM est carte offerte à prix très modique (moins de 10 euros) qui comporte un microcontrôleur ESP32 et une caméra OV2640. Une des caractéristiques les plus intéressantes de l'ESP32 étant la possibilité de communiquer en WiFi, une utilisation évidente de l'ESP-32 CAM consiste à transmettre en direct des images vidéo par WiFi (caméra de surveillance, etc.).

En plus d'une caméra OV2640, le module est équipé d'un lecteur de cartes micro SD qui pourra éventuellement servir à stocker des images ou des séquences vidéo.

Si vous êtes déjà familier avec les modules ESP-32 conventionnels, vous remarquerez toutefois que le module ESP32-CAM ne comporte aucun connecteur USB: pour programmer le microcontrôleur, vous devez utiliser un convertisseur USB-Série fonctionnant à un niveau logique de 3,3 V.

De plus, puisque la caméra accapare un certain nombre d'entrées/sorties du microcontrôleur, les broches GPIO disponibles sont beaucoup moins nombreuses que sur un module ESP-32 conventionnel (il n'y en a que 8, et 6 d'entre elles sont déjà connectées au lecteur de carte SD).

Le module que j'ai reçu était déjà assemblé: nul besoin de souder soi-même les connecteurs, ni même de connecter la caméra.

Dans ce court tutoriel, je vous explique comment, dans les minutes suivant la réception de mon module ESP32-CAM, j'ai pu utiliser un exemple fourni avec l'IDE Arduino pour diffuser en direct sur une page web la vidéo captée par la caméra.

Connexions de l'ESP32-CAM au convertisseur USB-série

Pour programmer mon module ESP32-CAM, j'ai utilisé un convertisseur USB-série qui fonctionne à un niveau logique de 3,3 V.


Pour la phase de programmation, les connexions étaient les suivantes:

  • Sortie 5 V du convertisseur USB-série:  Entrée 5 V de l'ESP32-CAM
  • Broche GND du convertisseur USB-série: Broche GND de l'ESP32-CAM
  • Broche TXD du convertisseur USB-série: Broche UDR de l'ESP32-CAM
  • Broche RXD du convertisseur USB-série: Broche UDT de l'ESP32-CAM
  • Broche IO0 branchée à GND



Le module est donc alimenté en 5 V pendant la programmation (je n'ai pas testé, mais j'ai lu sur des forums de discussion que certaines personnes ont eu des problèmes en tentant de programmer sous une alimentation de 3,3 V).

L'information transite de l'ordinateur vers le microcontrôleur (TXD / UDR) et du microcontrôleur vers l'ordinateur (RXD / UDT) à un niveau logique de 3,3 V (si votre convertisseur USB-série est muni d'un commutateur permettant de sélectionner le niveau logique, veillez à le régler à 3,3 V).

Pour mettre l'ESP32-CAM en mode programmation, il faut que la broche IO0 (ou GPIO 0) soit reliée à la masse (GND); on appuie ensuite sur le bouton "reset". Pour exécuter le programme, on débranche la broche IO0 et on appuie à nouveau sur le bouton "reset".

Après quelques heures de développement sur cette carte, j'ai bricolé un rudimentaire support en carton qui permet de maintenir la caméra à un angle pertinent tout en laissant le bouton "reset" facilement accessible. De plus, j'ai placé un interrupteur entre la broche IO0 et la masse pour éviter de devoir sans cesse débrancher et rebrancher un fil.





Réglages de l'IDE Arduino

Les cartes de la famille ESP32 ne sont pas incluses par défaut avec l'IDE Arduino; il faut les installer en passant par le "Gestionnaire de cartes". Si ce n'est pas déjà fait, vous trouverez la marche à suivre détaillée dans ce précédant billet.


Parmi les nombreuses cartes ESP32 disponibles, vous sélectionnez "AI Thinker ESP32-CAM". (À vrai dire, rien sur mon module ou sur la description offerte par le vendeur ne mentionne "AI Thinker", mais ce choix a fonctionné correctement.)

Vous ouvrez ensuite l'exemple "CameraWebServer" (Menu Fichier - Exemples - ESP32 - Camera - CameraWebServer).


Par défaut, le sketch est réglé pour être utilisé avec le modèle WROVER: utilisez plutôt la ligne 14 "#define CAMERA_MODEL_AI_THINKER".

De plus, écrivez les paramètres de votre réseau WiFi aux lignes 18 et 19.


Après vous être assuré que la broche IO0 est reliée à la masse GND et appuyé sur le bouton "reset", vous pouvez maintenant verser le sketch dans votre ESP32.


Si tout se passe bien, vous devriez voir, au bout de quelques dizaines de secondes, un message indiquant la réussite du téléversement.



Pour démarrer le programme, vous débranchez le fil reliant la broche IO0 à la masse et appuyez sur le bouton "reset".

Le moniteur série affiche l'adresse IP qui permettra de visionner l'image dans un navigateur web.


On copie cette adresse dans le navigateur web de notre choix. Dans la page web qui s'affiche, il s'agit de cliquer sur le bouton "Start Stream" pour que l'image captée par le module ESP32-CAM s'affiche à l'écran. Plusieurs contrôles situés à la gauche de la fenêtre permettent de modifier les caractéristiques de l'image.




En ce qui me concerne, cette première exploration du module ESP32-CAM s'est effectué sans le moindre pépin. J'espère bien, dans un proche avenir, apprendre à personnaliser les programmes pour, par exemple, enregistrer des images sur une carte SD, etc.

À lire également

D'autres articles sur l'ESP32-CAM:  un web server minimaliste , enregistrer des photos sur la carte microSD, time-lapse avec ESP32-CAMles LEDs de l'ESP32-CAM, mouvement panoramique avec servomoteur.

Mon article sur sur le module caméra du Raspberry Pi, et la liste des articles impliquant l'ESP32.

Yves Pelletier (TwitterFacebook)