Niveau 2 – Utiliser les liste n°1

Nombre de visites :
4

MAISON VIVANTE n°1

ou

Éclairage séquentiel de plusieurs pièces d'un bâtiment

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 ».
 
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.
 
 
VOICI LE PROGRAMME COMPLET
  • 3 listes contenant les états successifs de chaque LED pour 12 plages horaires ;
     
  • 1 ensemble de 4 blocs pour les initialisations des sorties ;
     
  • 1 fonction créée pour générée 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.
Les listes doivent impérativement avoir le même nombre d'éléments.
 
 
COMMENT UTILISER CES LISTES ?
Le cœur du programme
 
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 «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...»
 
 
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.


 
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 ?




 
ALLEZ ! ENCORE UN PETIT EFFORT
 
Et si on veut plus de plages horaires et plus de LED ?
 
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.
     
Petite video qui montre comment ajouter des items dans une fonction.
On a ainsi ajouté un élément de plus à la liste «LED_2_Timing».
Cet élément est vide.
Reste à luis 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
 
 
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.
 

 

 

© 2020 par Hubert SPERI – Créé avec Wix.com

WIX.png

Ce site ne contient aucun fichier avec des données personnelles et ne stocke aucune donnée personnelle lorsqu'on se connecte.

INYO_3.png
This site was designed with the
.com
website builder. Create your website today.
Start Now