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...
Nombre de visites :
22
L'icône ci-contre à droite indique que nous allons utiliser CocoBLOCKLY, un équivalent de ARDUBLOCKLY, mais avec beaucoup plus de fonctions.
CocoBLOCKLY fonctionne « en ligne ».
Nombre de visites :
Compteur de visites
MAISON VIVANTE n°1
Date de création : 27/01/2021
Dernière modification : 08/12/2021
00:00 / 00:16
Éclairage séquentiel
de plusieurs pièces d'un bâtiment
PROJET
Éclairer une maison ou un bâtiment en modèle réduit, c'est sympa.
Simuler la vie à l'intérieur de la maison, c'est mieux : on éclaire et on éteint 2, 3 ou 4 pièces (ou zones) différentes, de manière séquentielle, sur un cycle suffisamment long pour ne pas remarquer la répétition de la séquence.
Voilà à quoi pourrait ressembler le programme :
Ça fonctionne, mais ce programme qui comprend déjà 16 blocs de fonctions ne traite que 4 plages horaires !
Imaginez la taille du programme si on désire travailler sur 12 ou 24 plages horaires !
96 blocs pour 24 plages horaires et 3 sorties, et environ 120 lignes de code C++ !
Il y a un moyen plus élégant et bien plus efficace : LES «LISTES»
(cette fonction n'est pas disponible dans ARDUBLOCKLY)
Pour le programme ci-dessous, «heure fictive» désigne la durée des plages de temps qui représentent une heure réelle en réduction.
La valeur de cette «heure fictive» sera réglée en fonction de l'effet d'animation qu'on désire obtenir.
Programme complet
VOICI LE PROGRAMME COMPLET
-
3 listes contenant les états successifs de chaque LED pour 12 plages horaires ;
-
1 instruction pour fixer la durée de «l'heure fictive» ;
-
1 fonction personnelle pour générer la durée de la plage horaire ;
-
1 boucle de comptage pour parcourir les valeurs successives de chacune des 3 listes.
Avouez que c'est plus élégant.
... et on va voir que c'est aussi beaucoup plus efficace.
Tout d'abord, LES INITIALISATIONS
Pour des raisons de confort de lecture du programme, on créé 1 variable :
«NBR_de_SECONDES_par_HEURE_FICTIVE».
Elle sera décrite plus bas.
Ensuite, la création des LISTES
-
Les variables «LED_x_Timing» contiennent chacune une liste de 12 valeurs, «LOW» ou «HIGH».
-
Chaque valeur correspond à l'état «éteint» ou «allumé» de la LED correspondante.
-
Dans cet exemple, la LED_1 sera successivement :
«éteinte»-«éteinte»-«éteinte»-«allumée»...
-
Le rôle du programme est de lire séquentiellement un jeu de 3 valeurs pour commander les 3 sorties.
Dans CocoBLOCKLY, le bloc «Create Number List With» se trouve dans la rubrique «Lists».
«HIGH» et «LOW» sont des valeurs numériques. Eh oui !
«HIGH» est l'état logique «1». «LOW» est l'état logique «0».
Note :
Dans cet exemple, les trois listes comportent chacune 12 éléments.
Ces 3 listes doivent impérativement avoir le même nombre d'éléments.
Utiliser les listes
COMMENT UTILISER CES LISTES ?
C'est le rôle de la boucle de comptage «count with... from... to... by...».
L'opérateur «the lenght of LED_1_Timing» détecte la taille de la liste «LED_1_Timing» et, dans le cas présent, prend la valeur «12».
A chaque tour dans la boucle de comptage, la variable «HEURE_COURANTE» augmente de «1» (paramètre «by 1»).
«HEURE_COURANTE» varie donc de «0» (from...) à «the lenght of LED_1_Timing – 1» (to...),
c'est à dire 12 – 1 = 11.
(... ce qui fait bien 12 éléments dans la liste).
«HEURE_COURANTE» contient donc le numéro d'ordre des variables («HIGH» ou «LOW») qu'on cherche à lire dans les 3 listes.
Cette instruction complexe se compose de 2 instructions simples.
-
«from LED_1_Timing get item at HEURE COURANTE» :
Cette instruction lit et récupère la valeur située dans la table «LED_1_Timing» au rang contenu dans «HEURE_COURANTE».
-
«set digital pin# LED_1...» :
Cette instruction affecte la valeur récupérée – «HIGH» ou «LOW» – à la sortie LED_1, càd la sortie n°2.
Autrement dit, concrètement :
Si la boucle de comptage est en train de lire la quatrième plage horaire, càd «HEURE_COURANTE» = 3, la valeur lue dans la table «LED_1_Timing» est «HIGH», donc on allume «LED_1» (sortie n°2).
La boucle de comptage ci-dessus traite de la même façon les 2 autres tables «LED_2_Timing» et «LED_3_Timing».
Fonction « HEURE »
FONCTION «ATTENDRE_1_HEURE_FICTIVE»
La boucle de comptage ci-dessus se termine par l'instruction «ATTENDRE_1_HEURE_FICTIVE».
C'est l'équivalent d'une instruction «wait...», mais qui nous convient mieux.
C'est une fonction personnelle construite qui détermine le temps pendant lequel un état donné d'éclairage des 3 LED reste actif.
Petit topo sur l'instruction «wait...»
En langage C++ : delay(ms)
«ms» est exprimé en millisecondes ⇒ «wait(1000) ; » génère un temps d'attente de 1000 ms = 1 seconde.
Le paramètre «ms» est un entier long, càd codé sur 32 bits et qui prend des valeurs comprises entre
0 et 2^32 - 1, soit 4 294 967 295 !
4 294 967 295 millisecondes, c'est environ 4 294 967 secondes, soit environ 1200 heures, soit encore 50 jours (presque).
Largement de quoi ajuster la valeur de l'heure fictive à nos besoins.
Mais...
Mais c'est juste ingérable : si on veut une heure fictive qui dure 8 minutes, soit 480 secondes, il faut régler le paramètre de «wait» (dans BLOCKLY) ou celui de «delay» (en langage C++), à la valeur 480000 !
...ce qui ne parle pas beaucoup.
Utiliser la seconde comme unité de temps nous parlerait plus que la milliseconde.
Revenons à notre fonction personnelle :
Dans la partie des initialisations, la valeur de la variable «NBR_de_SECONDES_par_HEURE_FICTIVE» est fixée à «3».
La boucle «repeat NBR_de_SECONDES_par_HEURE_FICTIVE times» va donc répéter 3 fois un temps d'attente de 1000 ms.
⇒ dans le cas présent, une heure fictive va donc durer... 3 secondes
– Ce n'est pas un peu court, 3 secondes ?
– Si. Mais lorsqu'on est en phase de test du programme, il vaut mieux ne pas être obligé d'attendre 12 fois plusieurs minutes pour s'apercevoir qu'il y a une erreur !
On fixera la vraie valeur de l'heure fictive quand tout sera au point.
Pour une heure fictive égale à 2 minutes, il faut juste fixer la valeur de la variable «NBR_de_SECONDES_par_HEURE_FICTIVE» à 120.
Si on préfère une heure fictive de 7 minutes cette même variable sera fixée à 420 (7 x 60).
C'est plus confortable que de raisonner en millisecondes, non ?
Bon, d'accord, vous aimeriez mieux raisonner directement en minutes.
Qu'à cela ne tienne.
Voici la fonction correspondante :
Remarquer «wait 60 000 millisecondes», soit 60 secondes, donc 1 minute.
Note :
Dans ce cas, en phase de test du programme, il faudra jouer à la fois sur 2 valeurs :
-
«NBR_de_MINUTES_par_HEURE_FICTIVE» qu'on réglera par exemple à «3» ;
-
«wait» sera réglé à 1000 ms ;
⇒ de cette façon la durée de l'heure fictive en phase de test sera de 3 secondes, comme précédemment.
Code C++
LE CODE EN LANGAGE C++
45 lignes de programme, commentaires compris.
Bien aérées, faciles à lire.
On remarquera que, contrairement à l'ébauche de programme au tout début de cet article, il suffit d'une seule ligne de code pour gérer chaque LED !
Le reste du travail est accompli par la boucle de comptage qui explore les 3 listes d'états.
Ajouté à cela une petite fonction personnelle, plus les initialisations, et c'est tout.
POUR LE FUN...
Bien que très compact, un programme sous forme de blocs devient vite... encombrant à l'écran.
Mais les concepteurs y ont pensé.
Clic de droite sur un bloc ouvre un menu contextuel qui contient
«Collapse Bloc».
En français : «Contracter le bloc».
Ceci permet de réduire considérablement l'encombrement visuel d'un programme en contractant les parties sur lesquelles on ne travaille pas pour l'instant.
Voilà ce que peut donner par exemple le programme ci-dessus une fois contracté (sauf le corps principal) :
A noter que le bloc «run first» ne peut pas être réduit non plus.
Sympa, non ?
Plus de plages
ALLEZ ! ENCORE UN PETIT EFFORT...
C'est vraiment très simple :
Pour une LED supplémentaire :
-
on créé une variable liste de plus : «LED_4_Timing» ;
-
par duplication d'une des trois autres fonctions «set LED_x_Timing / Create Number List with...» on créé une nouvelle liste ;
-
on affecte à cette liste le nom «LED_4_Timing» créé plus tôt.
Pour créer les plages horaires supplémentaires :
Ce sera un peu plus long.
Il faut ajouter autant d'éléments que désiré à chacune des 4 listes, pour que chacune d'elles contienne le même nombre de plages horaires.
-
(1) : dérouler le menu d'ajout d'item ;
-
(2) : clic maintenu sur l'item et le glisser à droite ;
-
(3) : venir accrocher ce nouvel item dans la liste des items et relâcher le clic.
On a ainsi ajouté un élément de plus à la liste «LED_2_Timing».
Cet élément est vide.
Reste à lui attribuer la valeur «HIGH» ou «LOW».
-
répéter ces opérations jusqu'à obtenir le nombre total de plages horaires désirées.
-
répéter ces opérations pour chacune des autres listes.
Pour utiliser la LED supplémentaire :
Ajouter le groupe de blocs «set digital pin# 5 to / from LED_4_Timing...» ;
... et c'est tout !
En effet :
-
la boucle «count with...» ci-dessus contient bien la ligne de traitement de la «LED_4» ;
-
«the length of...» connait la nouvelle taille des 4 listes (nombre total de plages horaires).
Pas besoin de s'en occuper : c'est le programme qui détecte automatiquement cette taille !
Conclusion
CONCLUSION
Le programme ci-dessus a un petit côté «universel».
Avec peu de modifications et sans que le programme gonfle exagérément, on peut très facilement :
-
augmenter le nombre de LED en sortie ;
-
augmenter le nombre de plages horaires ;
-
faire varier la durée de l'heure fictive (un seul paramètre à modifier) ;
On aurait pu se passer de la fonction «ATTENDRE_1_HEURE_FICTIVE» et se contenter de la fonction «wait». Mais c'est tellement plus élégant avec cette petite fonction personnelle.
Réalisations avec COCOBLOCKLY
bottom of page