Lévitation acoustique

J'ai fait l'essai d'un petit appareil permettant de mettre en lévitation, au moyen d'ultrasons, des petits morceaux mousse de polystyrène. On peut en trouver sur les boutiques en ligne pour pas très cher.

Le dispositif est constitué de deux émetteurs d'ultrasons de 40 kHz placés face à face, l'un au-dessus de l'autre. Vous avez peut-être déjà vu dans des cours de physique que lorsque qu'on superpose deux ondes identiques qui se déplacent en sens contraire, on obtient ce qu'on appelle une onde stationnaire: il y a certaines positions, qu'on appelle les noeuds,  pour lesquelles l'amplitude de l'onde est toujours nulle. À d'autres endroits, qu'on appelle les ventres, l'amplitude de l'onde est à son maximum.

Le circuit électronique qui contrôle les deux émetteurs à ultrason est constitué d'un microcontrôleur STC15W et d'un "MOSFET driver" TC4427.

Deux interrupteurs n'ont, d'après la documentation fournie par le vendeur, aucune utilité!

Près du jack réservé à l'alimentation, on peut lire la mention DC 12 V. Il s'agit toutefois d'une valeur maximale, car l'appareil fonctionne correctement avec une tension d'alimentation aussi basse que 5 V. 

Si vous préférez construire vous même votre lévitateur acoustique, vous trouverez facilement sur le web des instructions pour assembler un circuit constitué d'un Arduino, d'un L298N et de deux émetteurs prélevés sur des modules HC SR-04. Mais puisque l'Arduino sert strictement à provoquer l'oscillation de 40 kHz, aussi bien le remplacer par un simple NE555...

Yves Pelletier

Affichage sur un PC d'un graphique montrant les mesures prises par un Raspberry Pi Pico

Ce projet consiste à afficher à l'écran d'un ordinateur un graphique cartésien qui montre les données transmises par un Raspberry Pi Pico branché à un de ses ports USB (il s'agit d'un projet similaire à celui que j'avais réalisé il y a quelques années avec un Arduino).

Les donnés sont acheminées du Raspberry Pi Pico à l'ordinateur par une communication série à travers le câble USB. Le Raspberry Pi Pico est programmé en MicroPython, alors que l'ordinateur affichant le graphique exécute un script en Python en utilisant la bibliothèque Matplotlib.

Circuit

Pour faire mes tests, j'ai utilisé un potentiomètre branché à la broche GP26 du Raspberry Pi Pico. Il sera facile de modifier le script pour remplacer le potentiomètre par un capteur de votre choix.

Script en Micropython exécuté par le Raspberry Pi Pico

Le rôle du Raspberry Pi Pico se résume à peu de chose. D'abord, il doit vérifier s'il reçoit un message en provenance de l'ordinateur. Si c'est le cas, il doit envoyer à l'ordinateur la mesure du capteur ainsi que le moment où cette mesure a été prise.

L'envoi de données du Raspberry Pi Pico vers l'ordinateur se fait tout simplement par la commande "print()".

La réception d'un message série par le port USB est un peu plus compliquée et, surtout, moins intuitive. Il s'agit des lignes 20, 21, 24 et 25 du script (ça nécessite également l'inclusion des bibliothèques sys et select):

poll = select.poll() 

poll.register(sys.stdin, select.POLLIN)

res = poll.poll()     

mess = res[0][0].read(1) 

-

- 

Script en Python exécuté par l'ordinateur auquel est branché le Raspberry Pi Pico

Sur l'ordinateur hôte, le script est plus élaboré. Si ce n'est pas déjà fait, il faut d'abord installer la bibliothèque Matplotlib , qui prend en charge le tracé du graphique (si vous utilisez Thonny, l'installation est très facile en passant par le menu "Outil - Gérer les plugin...").  La méthode FuncAnimation() permettra une mise à jour régulière du graphique en y ajoutant de nouvelles mesures.

Le script cherche d'abord un port série disponible, et il s'y branche s'il n'en trouve qu'un seul (il demande à l'utilisateur de faire un choix s'il en trouve plusieurs). L'utilisateur doit ensuite choisir le nombre de secondes qui s'écouleront entre deux mesures consécutives.

Un graphique s'affiche alors à l'écran de l'ordinateur, et il se met à jour au rythme qui a été choisi par l'utilisateur. Voici un graphique obtenu pendant que je tournais lentement le bouton du potentiomètre.

Lorsqu'il est temps de prendre une nouvelle mesure, le script envoie le message "e" au Raspberry Pi Pico.

Le message "i" est envoyé au début d'un graphique, pour que le temps initial du graphique soit nul.

-

-

Astuce: exécution des deux scripts avec Thonny

Il est possible d'exécuter les deux scripts en utilisant Thonny, sans que Thonny n'intercepte les messages envoyés par le Raspberry Pi Pico. Voici comment j'ai procédé:

- J'ai d'abord exécuté le script sur le Pico au moyen de Thonny, en utilisant l'interpréteur Micropython approprié.

- J'ai ensuite sélectionné le menu "Exécuter - Déconnecter" sur Thonny. Cette action a pour effet d'interrompre les communications entre Thonny et le Raspberry Pi Pico, mais elle n'interrompt pas le script, qui continue son exécution de façon autonome.

- Finalement, j'ai changé d'interpréteur (menu "Exécuter - Sélectionner l'interpréteur...") et j'ai exécuté le deuxième script directement sur le PC.

Il existe d'autres options possibles, comme installer le premier script dans le Pico en le nommant "main.py" pour qu'il s'exécute automatiquement.

À lire également:

• Programmer le Raspberry Pi Pico en Micropython avec Thonny
• Graphique en temps réel des mesures prises par un Arduino
• Mesurer la température et l'humidité relative avec un DHT22 et un Raspberry Pi Pico
  
  

Yves Pelletier (Facebook)

Accéléromètre/gyro MPU-6050 et Raspberry Pi Pico (MicroPython)

Le MPU-6050 est une centrale inertielle qui combine un accéléromètre et un gyromètre. On peut s'en servir pour mesurer l'accélération, l'inclinaison et la vitesse angulaire. Dans cet article, nous explorons l'utilisation d'un MPU-6050 avec un Raspberry Pi Pico programmé en MicroPython.

L'accéléromètre permet de connaître l'accélération et/ou le champ gravitationnel selon 3 axes: x, y et z. Les axes x et y sont illustrés sur le module, alors que l'axe z est perpendiculaire au plan du module. Lorsque le module est immobile, à plat sur une table, une accélération de 1 g sera mesurée selon l'axe z, à cause de la force de gravité qui agit vers le bas. Si l'accélération mesurée est nulle selon les 3 axes, c'est que le module MPU-6050 est en chute libre!

Le gyromètre mesure la vitesse angulaire selon les 3 axes. Lorsque le module est immobile, les 3 composantes de la vitesse angulaire sont, en principe, nulles (une calibration est toutefois nécessaire pour que le résultat soit exact).

Connexions

Le module MPU-6050 comporte 8 connecteurs, mais seulement 4 d'entre eux sont nécessaires à son fonctionnement (2 pour l'alimentation, et 2 pour la transmission des données par I2C):

• Broche VCC du MPU-6050 : Sortie 3,3 V du Raspberry Pi Pico
• Broche GND du MPU-6050: Broche GND du Raspberry Pi Pico
• Broche SCL du MPU-6050: Broche GP9 du Raspberry Pi Pico
• Broche SDA du MPU-6050: Broche GP8 du Raspberry Pi Pico

Installation des pilotes imu.py et vector3d.py

Les bibliothèques nécessaires se trouvent sur le dépôt Github micropython-mpu9x50. Les fichiers "imu.py" et "vector3d.py" doivent être copiés dans la mémoire flash du Raspberry Pi Pico.

Script #1

Ce premier script affiche les mesures issues de l'accéléromètre et du gyromètre. À partir des données de l'accéléromètre, le script tente de déterminer si un des 3 axes (x, y ou z) s'approche de la verticale. À partir des données du gyromètre, le script indique si le module MPU-6050 est en train de tourner.

Exécutez ce script, et orientez le module MPU-6050 de différentes façon pour voir comment varient les valeurs affichées.

-

-

Script #2

Dans ce deuxième exemple, la LED intégrée du Raspberry Pi Pico s'allume lorsqu'on agite le module MPU-6050.

-

-

À lire aussi:

• Utilisation du MPU-6050 avec Arduino
• Mesurer une distance avec le HC-SR04 et le Raspberry Pi Pico
• Module GPS NEO 6MV2 et Raspberry Pi Pico 

Yves Pelletier (Facebook)

Visualiser les données d'un microcontrôleur avec Serial Studio

Serial Studio est un logiciel conçu pour afficher en temps réel, à l'écran d'un ordinateur,  les données qui lui sont acheminées par un microcontrôleur via une communication série (UART).  Plusieurs données différentes peuvent être affichées simultanément sous la forme de graphiques cartésiens, de jauges, de diagrammes en bâtons, etc. De plus, toutes les données sont automatiquement archivées sous la forme d'un fichier CSV.

Développé par Alex Spataru, Serial Studio est gratuit, open source et multi-plateforme; je l'ai utilisé sous Linux (Ubuntu), mais il existe également une version pour Windows et pour MacOS. J'ai fait mes tests avec Arduino Uno, mais n'importe quel microcontrôleur fera l'affaire.

Installation et démarrage de Serial Studio

Rendons-nous d'abord sur la page web de Serial Studio.

Le bouton "Install" vous permet de télécharger la version qui correspond à votre système d'exploitation.

La version Linux est un fichier AppImage: après l'avoir téléchargé, il s'agit de rendre le fichier exécutable (clic droit sur l'icône, on choisit "Propriétés" puis on coche "autoriser l'exécution du fichier comme un programme") et votre application est immédiatement fonctionnelle.

Lors du lancement de l'application, on voit très brièvement cet écran de démarrage...
 

...  puis une fenêtre comportant une console série, à gauche, et des réglages (settings) à droite.

À partir d'ici, les choses se compliquent un peu: une configuration est nécessaire avant de pouvoir utiliser Serial Studio.

Création d'un premier projet

Serial Studio a été conçu pour interpréter des données qui lui sont soumises en format JSON (JavaScript Object Notation). Deux options s'offrent à vous: vous pouvez programmer le microcontrôleur pour qu'il envoie les données en format JSON, ou vous pouvez fournir à Serial Studio un fichier JSON qui servira de modèle pour interpréter les données brutes transmises par le microcontrôleur. C'est cette deuxième option que je vous propose ("Parse via JSON project file").

Vous ne connaissez pas très bien le format JSON? Moi non plus!  Et ça n'a aucune importance: Serial Studio comporte un outil qui nous permettra de générer ce fichier d'une façon très conviviale.

Créons un premier projet simple dans lequel le microcontrôleur envoie de façon répétitive une donnée numérique qui devra être affichée en temps réel sous la forme d'un graphique cartésien.

Nous cliquons d'abord sur le bouton "JSON Editor", en haut à droite.

On choisit un tire pour notre premier projet (j'ai choisi "Projet1").

On clique ensuite sur le bouton "Add group". Un groupe peut contenir plusieurs données qu'on désire classer ensemble. Un même projet peut contenir plusieurs groupes, mais un seul groupe sera suffisant pour ce premier projet.

On peut donner un nom à ce groupe (j'ai choisi "Groupe 1"), puis on clique sur le bouton "Add dataset".

On donne un nom à cette donnée. Ici, je l'ai baptisée "Donnée 1" mais dans une application plus concrète, ce serait certainement plus pertinent de l'appeler "température", "luminosité", "vitesse", etc. On peut aussi définir les unités de mesure qui correspondent à cette donnée ("Units").

J'ai ensuite sélectionné "Generate plot" pour que le résultat soit affiché sur un graphique cartésien...

 ... j'ai également choisi le widget "Gauge" pour que le résultat s'affiche également sur une jauge...

 

... j'ai défini la valeur maximale et la valeur minimale que pourront prendre les valeurs (c'est optionnel pour le graphique cartésien, mais nécessaire pour que la jauge fonctionne correctement)...

...et j'ai cliqué sur le bouton "Save" en bas à droite.

On vous propose alors d'enregistrer le fichier JSON comportant ces paramètres à l'intérieur d'un dossier intitulé "Serial Studio", dans le répertoire "Documents". Les fichiers CSV dans lesquelles les données seront archivées seront générés au même endroit.

Si vous le désirez, vous pouvez ouvrir ce fichier JSON au moyen d'un éditeur de texte, afin de voir son contenu.

 

Programmation du microcontrôleur

Programmons maintenant notre microcontrôleur afin qu'il achemine périodiquement une valeur numérique par communication série.

Chaque envoi de donnée doit débuter par l'expression "/*" et se terminer par l'expression "*/" .

Voici un sketch Arduino qui calcule la valeur d'une fonction sinusoïdale variant entre -10 et +10, et qui envoie un résultat deux fois par seconde.

 -

 -

 Voici un échantillon des données générées par ce sketch:

 

Communication entre le microcontrôleur et Serial Studio

Pour établir la communication, il s'agit de sélectionner, dans le volet Setup de Serial Studio, le nom du port série correspondant au microcontrôleur ("COM port").

On choisit le même baud rate que celui qui a été utilisé dans programme du microcontrôleur, puis on clique sur le bouton  "Connect" en haut à droite.

Si les données reçues du microcontrôleur correspondent à la structure enregistrée dans le fichier json, le logiciel bascule en mode "Dashboard" et on peut voir les données s'afficher dans trois zones d'affichage: la valeur numérique, un graphique cartésien et une jauge. On peut rendre invisible n'importe laquelle des 3 zones au moyen des contrôles situés du côté gauche de l'écran. On peut aussi régler l'échelle de l'abscisse du graphique ("Points", soit le nombre de mesures conservées dans le graphique cartésien).

Envoi simultané de plusieurs données différentes

Essayons maintenant un projet un tout petit peu plus ambitieux: l'envoi simultané de 5 données différentes: deux valeurs numériques qui seront représentées sur un même graphique cartésien, une variable booléenne qui sera représentée à l'écran par une LED virtuelle (éteinte ou allumée), une valeur numérique représentée par une jauge et, finalement, une valeur numérique représentée par un diagramme en bâton.

Nous retournons donc à l'éditeur de JSON et créons un nouveau projet (bouton "Create new project".

Celui-là, je l'ai baptisé "Projet 2". J'ai créé un premier groupe ("Groupe 1") qui contiendra deux données qui seront affichées sur un même graphique cartésien. Pour cette raison, j'ai sélectionné, à droite du nom du groupe, l'item "Multiple data plot".

À l'intérieur du groupe 1, j'ai ajouté une première donnée ("Mesure 1")...

 ...puis une deuxième mesure ("Mesure 2"):

Je ne désire pas que les 3 données restantes apparaissent aussi sur le même graphique cartésien. Pour cette raison, je dois les placer dans un groupe distinct. Je créé donc un deuxième groupe ("Groupe 2"), que je laisse cette fois à l'option "Dataset widgets", et je crée, à l'intérieur du groupe 2, la mesure 3. Pour cette mesure, je coche l'option "Display LED" (cette donnée sera un booléen).

Toujours à l'intérieur du groupe 2, j'ajoute la mesure 4: une jauge pouvant varier de 0 à 10...

...puis la mesure 5, un diagramme en bâton pouvant varier de 0 à 20, mais qui sera affiché en rouge si la valeur dépasse 15.

 

Du côté Arduino, notre programme doit générer 5 valeurs séparées par des virgules, et encadrées par les expression "/*" et "*/".

Voici le sketch que j'ai utilisé:

 -

 -

...et voici un échantillon des messages générés:

Finalement, voici ce que ça donne lorsque j'établis la connexion entre Serial Studio et l'Arduino (j'ai masqué l'affichage "Groupe 2", qui était redondant et empêchait que tous les widgets soient visibles en même temps):

 

Conclusion

Pas mal du tout, ce logiciel!

Yves Pelletier (Facebook)

 

Étude du pendule avec un potentiomètre et Arduino

Récemment, mon attention a été attirée par un article de la revue The Physics Teacher* dans lequel on présente un montage expérimental qui permet d'étudier le mouvement d'un pendule au moyen d'un potentiomètre branché à une carte Arduino. Dans ce montage, le potentiomètre est utilisé pour mesurer en temps réel la position angulaire du pendule.

L'article du Physics Teacher propose l'analyse d'un "pendule pesant"  constitué d'une tige rigide de masse non-négligeable et d'une masse oscillante de taille non-négligeable. De mon côté, j'ai fait quelques essais avec un dispositif s'apparentant plutôt à un "pendule simple" (qui est, en principe, constitué d'une masse ponctuelle suspendue à une ficelle de masse négligeable).

Mon pendule était constitué d'une masse de 500 grammes suspendue à un fil de fer de 91 cm de longueur. L'autre extrémité du fil de fer était attachée à l'axe d'un potentiomètre.

Il faut prendre soin de fixer le fil de fer de façon à ce qu'il oblige la partie rotative du potentiomètre à tourner en suivant le mouvement du pendule.

Bien entendu, le potentiomètre était branché à une des entrées analogiques de l'Arduino. Puisque le signal n'excédait jamais 3,3 V pendant l'oscillation du pendule, j'ai choisi d'utiliser une tension de 3,3 V comme référence, afin d'améliorer un peu la résolution de la conversion analogique-numérique (j'ai relié la sortie 3V3 à l'entrée AREF, et j'ai ajouté la commande "analogReference(EXTERNAL)" au début du sketch). 

Dès les premiers essais, le moniteur série de l'IDE Arduino a montré des résultats encourageants. Je m'attendais à un amortissement plus important, à cause du couple nécessaire pour faire tourner le potentiomètre. Avec une masse de 500 grammes, on peut facilement le négliger si on se limite à quelques oscillations.

J'ai ensuite utilisé un sketch qui mesurait également le temps associé à chaque mesure de position angulaire afin de coller dans un tableur les mesures affichées dans le moniteur série.

Mis à part un aplatissement un peu suspect au sommet,  la courbe concorde assez bien avec ce que prévoient les équations théoriques. La période du pendule, mesurée au moyen des données obtenues, est de 1,92 seconde, ce qui correspond bien avec ce qu'on peut calculer théoriquement pour un pendule  simple de 91 cm de longueur.

* Inexpensive Physical Pendulum with Arduino, par Milentije Lukovic, Vanja Lukovic, Milos Bozic et Vojislav Vujicic, The Physics Teacher vol. 59, numéro 6, Septembre 2021, pages 432-435 (American Association of Physics Teachers).

À lire également

• D'autres expériences scientifiques impliquant Arduino  

Yves Pelletier (Facebook)