top of page
Difficile de faire plus simple : une seule pièce d'habitation et un toit plat.
Dimensions extérieures : environ 45 x 54 x 33 mm.
Quatre ouvertures dont une porte.
... et c'est tout.
Plus modeste, on peut pas.
Les murs ont une épaisseur de 3 mm.
Difficile de faire plus simple : une seule pièce d'habitation et un toit plat.
Dimensions extérieures : environ 45 x 54 x 33 mm.
Quatre ouvertures dont une porte.
... et c'est tout.
Plus modeste, on peut pas.
Les murs ont une épaisseur de 3 mm.
Pour imprimer cette petite maison j'ai choisi du fil PolyWood. C'est un PLA avec du bois qui donne à la pièce un aspect "bois mat" ou "terre sèche". Facile à enduire et à peindre.
Suivant l'imprimante utilisée, il sera nécessaire de réduire au papier de verre les dimensions du toit pour qu'il s'encastre correctement et vienne en appui sur les petites nervures qui ceinturent le bâtiment à l'intérieur des murs.
Pour éviter l'affaissement des linteaux l'impression est paramétrée avec "supports d'impression", c'est à dire que les porte et fenêtres (ben oui, ya qu'une porte ! ) seront remplies d'une sorte de nid d'abeille qui supportera les linteaux au moment de leur impression.
Il faudra ensuite désoperculer toutes les ouvertures pour les débarrasser de ces supports, puis ébavurer correctement.
La maison, avec son toit, et la porte partiellement désoperculée.
Note :
Cette petite maison peut être facilement imprimée à l'échelle "N".
Il suffit, dans CURA by Dagoma, d'utiliser les mêmes fichiers ".stl" et d'appliquer le coefficient de réduction 0,54. (Hé oui ! Pas besoin de redessiner).
L'impression prendra 20 minutes et 4 grammes de PLA pour un coût matière de l'ordre de 0,20€ !
Si l'échelle 1:43 vous tente, il suffit d'appliquer un coefficient x2 dans CURA.
Il faudra 5 heures d'impression et 73 grammes de PLA (moins de 4€).
C'est encore jouable.
Ah ! petite remarque : le bâtiment est marqué "HUGO 2017" à l'intérieur.
Mon petit fils voulait que "son œuvre" soit signée ! (c'est la seule chose que j'ai faite sur ce modèle).
Téléchargements :
Petite maison en adobe
Un de mes petits fils voulait absolument dessiner et imprimer une maison en 3D.
J'ai orienté son choix vers un modèle simple : une petite maison de paysan modeste de la région de Santa Fe, en adobe, qui va me servir sur mon réseau. Tant qu'à faire...
BLASCARR
Nombre de visites :
10
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
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 ;
Ben dis donc !
Ambitieux.
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.
CABLAGE SUR LA PLAQUE D'ESSAI
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
– À la lecture du sujet, le programme risque d'être plutôt complexe !
– 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.
– Je sais faire !
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 :
– Pas terrible comme éclairs !
– 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 1 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 :
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 :
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 :
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.
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.
«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.
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.
Constitution (provisoire) de la fonction personnelle «Salve»
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.
– Tu peux essayer maintenant...
– 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
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»
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 >>>
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 :
– C'est fini ?
– 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» :
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 :
– C'est fini ?
– 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»
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.
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.
La fonction «random...» génère 5 valeurs différentes.
«Volume» peut donc prendre les valeurs 5, 10, 15, 20, 25.
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.
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»
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»
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 :
– C'est fini ?
– 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 :
La fonction «Attente_fin_du_son» est modifiée par l'ajout de 2 instructions :
«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 :
Pour finir, on ajoute l'appel à la fonction «Affichage_de_controle» dans «Arduino loop forever» :
Bien entendu, on n'oubliera pas la déclaration «Setup Serial : speed to 9600 bps» :
Après le téléversement du programme, on ouvre le moniteur et on obtient un affichage tel que celui-ci :
That's all Folks !
Réalisations avec ARDUBLOCKLY
bottom of page