ARDUBLOCKLY.png
BLASCARR
Nombre de visites :
9
Copie de bandeau2.jpg
Nombre de visites :
Compteur de visites
ORAGE avec SONS
Le programme est développé avec ARDUBLOCKLY Blascarr,
version «in line» accessible ici :
https://ardublockly.blascarr.com/ardublockly/#

Date de création : 08/12/2021

Dernière modification : 25/12/2021

Download_1.png
00:00 / 00:16
PROJET
Simuler un orage, avec éclairs et son...
... mais pas n'importe quel orage :
  • une douzaine de sons différents ;
  • VRAIS enregistrements sonores ;
  • les éclairs ont des durées aléatoires ;
  • le nombre d'éclairs par salve est aléatoire ;
  • l'intensité lumineuse des éclairs est aléatoire ;
  • le retard entre la salve d'éclairs et le son est aléatoire (pour simuler des coups de tonnerre proches ou lointains) ;
  • le volume sonore est fonction du retard entre la salve d'éclairs et le son du tonnerre, donc de la distance présumée du coup de tonnerre ;
  • l'intensité lumineuse des éclairs est fonction du retard entre la salve d'éclairs et le son, donc de la distance présumée du coup de tonnerre ;
confused-smiley.png
Ben dis donc !
Ambitieux.
ordi.gif
On va y arriver...
MATÉRIEL
On utilise une carte ARDUINO UNO.
Une ARDUINO MINI ou MICRO conviendrait aussi.

Pour lire les séquence sonores, on utilise un petit module «DFPlayer Mini».

Il comporte un amplificateur intégré de 3 watts qui permet de diffuser les sons sur
une enceinte d'impédance 8 ohms.

Si on utilise un amplificateur externe, on peut même disposer du son en stéréo...
et avec plus de puissance.


Pour les éclairs on utilise des «panels boards» à LED et qui fonctionnent sous 5 V DC.

Ces «panels boards» seront actionnés par un étage de puissance à MOSFET, afin de ne pas
surcharger la sortie de la carte ARDUINO.
 
Petit inconvénient : ce projet nécessite au total 3 blocs d'alimentations :
  • 9 V DC pour la carte ARDUINO ;
  • 5 V DC pour le module DFPlayer : en effet, l'amplificateur intégré de 3W ne peut pas être alimenté à partir du +5 V de la carte ARDUINO (pas assez puissant) ;
  • 5 V DC pour le ou les «panels boards» qui sont eux aussi des gros consommateurs.
Note : si on utilise une carte ARDUINO MICRO, le module DFPlayer Mini et la carte ARDUINO peuvent partager la même alimentation 5 V DC.
l5.jpg
MP3_Player.jpg
CABLAGE SUR LA PLAQUE D'ESSAI
ORAGE_BREADBOARD_1.png

Les deux possibilités de câblage des LED sont implantées à gauche du breadboard.
On utilise l'une et/ou l'autre en fonction des besoins :
  • la LED seule pendant la phase de mise au point du programme ;
  • le «panel board» piloté par le MOSFET en utilisation réelle.


DFPlayer :
Tinkercad ne propose pas le composant DFPlayer.
Il est représenté par un simple image qui indique le rôle des différentes broches.
 
Les alimentations 5 V DC :
Elles sont représentées «au repos» : consommations nulles.
 
INVENTAIRE DES LIAISONS

«2» ARDUINO ⇒ «RX» DFPlayer Mini
«3» ARDUINO ⇒ «TX» DFPlayer Mini
«9» ARDUINO ⇒ sortie vers LED et/ou «panel board»
«10» ARDUINO ⇒ «BUSY» DFPlayer Mini

«SPK_1» DFPlayer Mini ⇒ HP
«SPK_2»HP

«VCC» DFPlayer Mini ⇒ alimentation 5 V DC n° 1

«+ 5 V» du panel board ⇒ alimentation 5 V DC n° 2


Note 1 :
Les masses des 3 alimentations doivent être reliées ensemble.

Note 2 :
Il est nécessaire d'utiliser 2 alimentations 5 V DC séparées.

En effet, si on utilise une seule alimentation 5 V DC pour le «panel board» et pour le DFPlayer Mini, les variations rapides et brutales de consommation occasionnées par la succession des flashs des éclairs provoque des parasites dans le haut parleur connecté au DFPlayer.


 
GÉNÉRER UNE SALVE D'ÉCLATS
voyante.gif

– À la lecture du sujet, le programme risque d'être plutôt complexe !
 
informatik.gif

– Il l'est. Mais on va procéder pas à pas... tranquillement...
 

La première étape consiste à bâtir la fonction personnelle qui génère un éclair, c'est-à-dire une «salve d'éclats».

Générer un «éclat» c'est – ni plus ni moins – faire clignoter une LED une seule fois, avec un paramétrage adapté.

Cependant, au lieu d'utiliser la fonction «set digital pin...» on préférera utiliser «set analog pin...».
On verra très bientôt pourquoi.
 
emoticone_smartphone_1.png

– Je sais faire ! 
 
ORAGE_SALVE_1.png

On peut vérifier qu'on a bien des éclats rapides, en continu.

Si maintenant on désire générer une salve de 12 éclats, en espaçant les salves de 3 secondes :

 
ORAGE_SALVE_2.png
Fache.png

– Pas terrible comme éclairs !
 
informatik.gif

– Pas à pas, je te dis...
 
 

Un «éclair», visuellement, qu'est-ce que c'est ?

Approximativement :
  • l'éclair est constitué d'un nombre d'éclats successifs aléatoire ;
  • l'intensité de chaque éclat est aléatoire ;
  • la durée de l'éclat est aléatoire ;
  • l'intensité lumineuse minimale entre éclats est aléatoire ;
  • la durée entre éclats est aléatoire ;

Il existe une instruction «Math» pour cela : «random integer from [a] to [b]».

 
Instruction «random integer from [a] to [b]»
 
Dans le langage C++, «random integer from [a] to [b]» génère un nombre entier compris entre a et (b-1).
 
Dans ARDUBLOCKLY,  «random integer from [a] to [b]» génère un nombre entier compris entre a et b.


Par exemple, «random integer from [1] to [12]» génère un nombre entier compris entre et 12.

Grâce à cette fonction il va être facile (presque) de rendre aléatoire chacun des paramètres de l'éclair.

 
Nombre aléatoire d'éclats

Pour générer aléatoirement entre 4 et 12 éclats par salve, le plus évident semble :
 
Random_integer_1.png

Cette instruction est capable de générer 12 valeurs différentes.

Très bien.

Mais a-t-on besoin des 12 valeurs différentes possibles ?
Une salve de 8 éclats ne paraîtra pas sensiblement différente d'une salve à 6, 7, 9 ou 10 éclats.

Quatre ou cinq valeurs différentes sont donc bien suffisantes et offrent un meilleur effet de contraste entre les durées des salves.

C'est ce que réalise l'instruction ci-dessous :
 
Random_integer_2.png

Explication :

Cette instruction est capable de générer 20 valeurs différentes, comprises entre 1 x 5 = 5 et 4 x 5 = 20.

On obtient au minimum 5 éclats par salve, et au maximum 20 éclats par salve, mais avec seulement 4 valeurs différentes : 5, 10, 15 et 20.

L'instruction complète devient :
 
Random_integer_3.png
Intensité aléatoire d'un éclat

Dans l'instruction «set analog pin #9 to [a]», le paramètre «a» peut prendre les valeurs de 0 à 255.

Voici l'instruction pour un éclat dont l'intensité peut varier de 50 à 250.

 
Random_integer_4.png

Explication :

Seulement 5 valeurs différentes.

La plus faible : 1 x 50 = 50.
La plus élevée : 5 x 50 = 250.

⇒ gamme de valeurs possibles pour la luminosité : 50, 100, 150, 200 et 250.




De même, l'intensité lumineuse minimale de l'éclat (pseudo-extinction) variera aléatoirement de 0 x 50 = 0 à 4 x 50 = 200 en 5 valeurs différentes : 0, 50, 100, 150 et 200.
 
Random_integer_5.png

«0» réalise une extinction complète.

Les autres valeurs ne font qu'une atténuation.
 
Durée aléatoire d'un éclat et de sa pseudo-extinction

Pas besoin de tout ré-expliquer.
 
Random_integer_6.png

Seulement 4 valeurs différentes, échelonnées ainsi : 25, 50, 75 et 100 millisecondes.




De même, la durée de pseudo-extinction prendra 4 valeurs possibles : 15, 30, 45 et 60 millisecondes.
 
Random_integer_7.png
Constitution (provisoire) de la fonction personnelle «Salve»
Random_integer_8.png

Remarque :

En sortant de la boucle «repeat...» on a ajouté une instruction «set analog pin # 9 to [0]».

Indispensable !

Pourquoi ?
Tout simplement parce que l'instruction «set analog pin # 9 to (random integer from 0 to 4) x 50» n'éteint complétement la LED sur la sortie «9» qu'en moyenne 1 fois sur 5.

«set analog pin # 9 to [0]» force donc la sortie «9» à la valeur «0» quand une salve se termine.
 
informatik.gif

– Tu peux essayer maintenant...
 
emoticone_smartphone_1.png

– Ah ! Oui. C'est mieux !
...
– C'est fini ?

 

On pourrait se contenter de cela.
Les salves ont bien des nombres d'éclats différents et avec des luminosités différentes pour chaque éclat, mais :
  • les salves reviennent à intervalles réguliers de 1 seconde ;
  • on n'a pas encore le son ;

 
Où il est question du DFPlayer Mini...

La diffusion du son, c'est l'affaire du DFPlayer Mini.
Que faudra-t-il faire ?
 
Simple :
  • dans l'IDE ARDUINO on installe la bibliothèque nécessaire à la compilation ;
  • dans ARDUBLOCKLY on déclare qu'on utilise le module DFPlayer ;
  • on crée une fonction personnelle «Coup_de_tonnerre» qui lit aléatoirement l'une des 13 séquences sonores que j'ai personnellement enregistrées sur ma carte micro-SD ;
  • après chaque salve, on appelle la fonction «Coup_de_tonnerre».
     
Note : Le choix d'utiliser ARDUBLOCKLY Blascarr est précisément dicté par ​le fait que la catégorie «MP3» propose toutes les instructions nécessaires pour l'utilisation du module DFPlayer Mini.
Installation de la bibliothèque pour DFPlayer dans l'IDE ARDUINO
  • ouvrir l'onglet «Outils» ;
  • choisir «Gérer les bibliothèques» ;
  • dans le champ «Filtrer votre recherche», taper «DFRobotDFPlayer» ;
⇒ la bibliothèque «DFRobotDFPlayerMini» apparaît ;
  • choisir «Installer».
Dans ARDUBLOCKLY Blascarr, on déclare l'utilisation de DFPlayerMini​
DFPlayer_1.png
 
D'une part, dans la catégorie «Serial» on sélectionne le bloc «SoftwareSerial Setup».
On fixe RX sur l'a broche «2» et TX sur la broche «3».
Ceci concerne le «Rx» et le «Tx» de l'ARDUINO.
(On aurait pu choisir d'autres broches).
  • RX de l'ARDUINO est relié à la broche TX du DFPlayerMini ;
  • TX de l'ARDUINO est relié à la broche RX du DFPlayerMini ;
D'autre part, dans la catégorie «MP3» on sélectionne le bloc :
«DFPlayer [myDFPlayer] in serial [mySoftwareSerial]»
 
... et on l'installe dans «Arduino run first»
La fonction personnelle «Coup_de_tonnerre»
DFPlayer_2.png
 
Dans «Arduino run first», créer une variable «Numero_du_son». On ne lui affecte pas de valeur.

On utilise cette variable dans la fonction «Coup_de_tonnerre» pour choisir
de façon aléatoire l'une des 13 séquences sonores présentes sur la carte Micro-SD.
Téléchargement des sons ici >>>
Download_1.png


L'instruction «wait [1000] milliseconds» met en place un retard de 1 seconde entre la fin de l'éclair et le début du son.

On verra plus tard comment ce retard peut être modulé pour simuler un coup de tonnerre proche ou lointain.


«DFPlayer [myDFPlayer] Set Volume [20]» limite le volume sonore au niveau «20».

On verra plus tard comment ce volume peut être modulé pour simuler un coup de tonnerre proche ou lointain.
(Le niveau sonore peut être réglé entre 0 et 30).


«DFPlayer [myDFPlayer] play song number  [Numero_du_son]» démarre la lecture du son choisi aléatoirement juste avant.
 


Voici à quoi ressemble le corps principal du programme à ce stade :
 
DFPlayer_3.png
Emoticone_doute.jpg

– C'est fini ?
 
informatik.gif

– Tu peux essayer mais ce n'est pas génial. «Pas à pas» j'ai dit...
 



Et pourquoi ce n'est pas génial ?

– la salve démarre ;
– quand la salve se termine il y a un délai de 1 seconde (dans la fonction «coup_de_tonnerre») avant de lancer la lecture du son ;
– le son démarre et on sort tout de suite de la fonction «Coup de tonnerre» parce que c'est le DFPlayer qui joue cette séquence, pas l'ARDUINO.;
– la séquence sonore dure (avec les sons proposés) entre 7 et 34 secondes.


DONC :

... une seconde plus tard, grâce à la temporisation entre salves inclue dans la boucle «Arduino loop for ever», une nouvelle salve démarre.

Elle est suivie du déclenchement de la lecture d'un nouveau son alors que la diffusion du son précédent n'est probablement pas encore terminé :

⇒ le premier son est interrompu et le deuxième démarre ;
on obtient un effet sonore assez curieux et désagréable. 




 
Attendre que la diffusion du son soit terminée
Broche «BUSY» du DFPlayer (disponibilité du module) :

Le niveau électrique sur cette broche indique si le module est occupé à jouer un son ou non :
  • le niveau est «LOW» lorsque le module joue un son. La LED rouge du DFPlayer est allumée.
  • le niveau est «HIGH» lorsque le module est libre.
     
Dans ce programme, «BUSY» du DFPlayer est connectée à l'entrée «10» de l'ARDUINO.
 

Créer une fonction personnelle «Attente_fin_du_son» :
 
DFPlayer_4.png

Explications :
 
  • tout d'abord «wait...» attend 1 seconde pour être certain que la diffusion du son est commencée.
On pourrait se contenter de 200 à 500 ms. Ce n'est pas une valeur critique puisque le son le plus court que j'ai enregistré sur la carte dure 7 secondes.
 
  • la boucle «repeat while...» tourne sans rien faire (aucune instruction DANS la boucle) tant que l'état de l'entrée «10» est «LOW», càd tant que le DFPlayer est occupé à jouer le son.

⇒ ainsi on ne quitte la fonction personnelle «Attente_fin_du_son» que lorsque la diffusion du son est terminée.

Le corps du programme maintenant n'a plus besoin de l'instruction «wait...».
C'est la durée de la séquence sonore qui détermine le rythme de la succession des éclairs.
 

 
À ce stade, voici à quoi ressemble le programme :
 
ORAGE_ETAPE_3.png
Emoticone_doute.jpg

– C'est fini ?
 
informatik.gif

– Non, mais tu peux admirer le résultat.
– Maintenant, on va entrer «dans le dur» !
Volume sonore, retard et facteur d'intensité lumineuse
Eh oui ! Le programme est opérationnel :
  • salves aléatoires ;
  • son aléatoire ;
  • durée entre 2 coups de tonnerre conditionnée par la durée de la séquence sonore en cours de diffusion ;

Mais :
  • le retard est constant entre la fin de la salve d'éclairs et le déclenchement du son ;
  • pas d'atténuation de luminosité si l'éclair est lointain ;
  • pas d'atténuation du son si l'éclair est lointain.
 
 
Trois nouvelles variables : «Volume», «Retard», «Facteur_d_intensite»
ORAGE_ETAPE_4D.png

Déclarer les variables dans «Arduino run first» sans leur attribuer de valeur : par défaut, elles prennent la valeur «0».

Le programme se chargera de leur attribuer leurs vraies valeurs.


Dès que la fonction personnelle
«Retard_du_son_Volume_et_Facteur_d_intensite»
ci-dessous sera créée, elle sera installée au début de «Arduino loop forever», comme on le voit ci-contre.



 


Fonction personnelle «Retard_du_son_Volume_et_Facteur_d_intensite»

Elle utilise les 3 nouvelles variables.
 
ORAGE_ETAPE_4.png
 
La fonction «Retard_du_son_Volume_et_Facteur_d_intensite» a pour rôle de calculer les valeurs qui vont permettre de moduler le volume sonore, le retard et l'intensité lumineuse.

Or on n'a pas d'indication de distance de l'éclair.

J'ai choisi d'approcher le problème par la variable «Volume» : 
  • plus le volume sonore est faible, plus la distance de l'éclair est importante ;
  • plus le volume sonore est faible, plus l'intensité lumineuse moyenne de l'éclair est faible.
 

La variable «Volume» est facile à rendre aléatoire.
D'après la notice du DFPlayer MINI, sa plage de variation possible est comprise entre 0 et 30.
ORAGE_ETAPE_4A.png
La fonction «random...» génère 5 valeurs différentes.

«Volume» peut donc prendre les valeurs 5, 10, 15, 20, 25.

 
ORAGE_ETAPE_4C.png

Le facteur d'intensité lumineuse vient moduler la valeur aléatoire de chaque éclat, donnant ainsi un effet d'éloignement de l'éclair.

Explication :

Le calcul est simple : (Volume / 5).

«Volume» peut prendre les valeurs 5, 10, 15, 20 et 25.
«Facteur_d_intensite» prendra donc les valeurs 1, 2, 3, 4 et 5.


 
ORAGE_ETAPE_4B.png

La détermination de la variable «Retard» demande un peu plus d'astuce.
 
Explications :

On veut que le retard minimal, entre l'éclair et le son, soit nul (zéro secondes), quand le volume vaut «25».
On veut aussi qu'il puisse être de l'ordre de 2 secondes quand le volume vaut «5».

Comment convertir une plage «5 – 25» en une plage «2000 – 0» ?

Un calcul tout simple permet de le faire : (25 - Volume) x 100
  • si «Volume» vaut 25 ⇒ «Retard» vaut zéro.
    Le son arrive sans délai après l'éclair, et avec le volume maximal.
  • si «Volume» vaut 5 ⇒ «Retard» vaut (25 - 5) x 100, soit 2000 millisecondes.
    Le son arrive tardivement et le volume sonore est faible.
  • «Volume» = 10 ⇒ «Retard» = (25 - 10) x 100 soit 1500 millisecondes ;
  • «Volume» = 15 ⇒ «Retard» = (25 - 15) x 100 soit 1000 millisecondes ;
  • «Volume» = 20 ⇒ «Retard» = (25 - 20) x 100 soit 500 millisecondes ;
Modification de la fonction «Salve»
ORAGE_ETAPE_5A.png

Dans les deux instructions «Set analog pin...», la valeur «50» est remplacée par (Facteur_d_intensite x 10).

(Facteur_d_intensite x 10) prendra donc les valeurs 10, 20, 30, 40 et 50.




 
Modification de la fonction «Coup_de_tonnerre»
ORAGE_ETAPE_5B.png

L'instruction «wait ...» utilise la variable «Retard» qui peut prendre les valeurs de 2000 à 0 millisecondes.

Une instruction supplémentaire – «DFPlayer myDFPlayer Set Volume [Volume]» – module le volume sonore entre 5 et 25 en 5 valeurs différentes possibles.



Récapitulatif pour les valeurs extrêmes :

«Volume» = 5 ⇒ «Retard» = 2000 ⇒ «Facteur_d_intensite» = 10 ⇒ éclairs lointains ;
«Volume» = 25 ⇒ «Retard» = 0 ⇒ «Facteur_d_intensite» = 50 ⇒ éclairs très proches ;




Voici comment se présente le programme complet :
 
ORAGE_ETAPE_6.png
Emoticone_doute.jpg

– C'est fini ?
 
informatik.gif

– Oui. Cette fois c'est fini... enfin, presque...
AFFICHAGE DE CONTRÔLE

J'ai eu envie de contrôler – autrement que visuellement – si le programme balayait bien toutes les possibilités.
  • numéro de séquence sonore ;
  • durée de la séquence ;
  • volume ;
  • retard ;
  • facteur d'intensité

Ces renseignements permettent de vérifier que, par exemple, quand le volume sonore est maximal, le retard est minimal et le facteur d'intensité est maximal.

On peut aussi vérifier la durée exacte de chaque séquence sonore.

Deux variables permettent de mesurer cette durée :
 
ORAGE_controle_A.png
 
 

La fonction «Attente_fin_du_son» est modifiée par l'ajout de 2 instructions :
 
ORAGE_controle_B.png


«current elapsed Time», temps écoulé depuis la mise en route de l'ARDUINO, est stocké dans la variable «Initialisation_timer» 1 seconde après le début de la fonction «Attente_fin_du_son».

Lorsque la boucle d'attente «repeat while...» est terminée, la variable «Duree_du_son» reçoit la valeur de la durée comptée en millisecondes.

À la fa fin de l'expression, l'opération «+ 1000» sert à compenser les 1000 millisecondes perdues à cause de l'instruction «wait 1000 milliseconds» du début de la fonction.



Une fonction personnelle «Affichage_de_controle» organise l'affichage des résultats sur le moniteur :
 
ORAGE_controle_C.png



Pour finir, on ajoute l'appel à la fonction «Affichage_de_controle» dans «Arduino loop forever» :
 
ORAGE_controle_D.png



Bien entendu, on n'oubliera pas la déclaration «Setup Serial : speed to 9600 bps» :
 
ORAGE_controle_E.png



Après le téléversement du programme, on ouvre le moniteur et on obtient un affichage tel que celui-ci :
 
ORAGE_controle_F.png
Looney_tunes.png

That's all Folks !
 

Réalisations avec ARDUBLOCKLY