ARDUBLOCKLY.png
 
Jour-nuit-6.jpg
SIMULER LE JOUR ET LA NUIT
C'est un des projets de Thibaut : éclairer la pièce où se trouve son réseau, en simulant le lever du soleil, la lumière de la pleine journée, le coucher de soleil, suivi de la nuit...
... mais sur une durée «à l'échelle», càd raccourcie  à une quinzaine de minutes.
Création : 01-12-2021 ; mise à jour : 03-12-2021
​​
 
Le projet complet de Thibaut vise à éclairer de façon variable une pièce entière.
Ceci implique d'utiliser des lampes à LED suffisamment puissantes, et donc d'ajouter en sortie de la carte ARDUINO un organe de commande de puissance. (MOSFET par exemple).
Dans cet article on ne traitera que l'aspect «programmation».
DE QUOI AVONS-NOUS BESOIN ?

Tout d'abord une petite réflexion sur l'alternance jour-nuit et la variation d'intensité lumineuse au cours d'un cycle de 24 heures...

On peut décomposer le cycle jour-nuit de la façon suivante :
  • le soleil se lève ⇒ une lampe s'allume et l'intensité lumineuse croît pendant environ 3 heures ;
  • le jour est établi ⇒ l'intensité lumineuse est constante pendant 6 heures ;
  • le soleil se couche ⇒ l'intensité lumineuse décroît pendant environ 3 heures ;
  • la nuit est là ⇒ une lampe émet une faible clarté constante pendant toute la durée de la nuit.
⇒ une lampe pour le jour (ou plusieurs en parallèle).
⇒ une lampe pour la nuit.
Note : les temps ci-dessus ne sont donnés qu'à titre indicatif.

On peut simplifier : la lampe qui donne l'intensité lumineuse nocturne peut rester allumée même en journée.
En effet, quelques dizaines de minutes (en temps réel) après le lever du jour, l'intensité du jour dépasse l'intensité lumineuse nocturne qui devient négligeable.
On aura besoin de :
  • une lampe (bleue par ex.) de faible intensité allumée en permanence ;
  • une lampe blanc chaud pour le cycle «lumière du jour».
 
Donc on n'a besoin de commander qu'une seule sortie sur l'ARDUINO.
 
– Pour varier un peu les plaisirs, nous allons utiliser
une démarche différente pour construire le programme :
Dès le départ nous allons penser «variables» et «fonctions personnelles»
et mettre en place TOUTE la structure AVANT de «remplir» les fonctions personnelles.
informatik.gif
INVENTAIRE DES VARIABLES NÉCESSAIRES
 
  • «Duree_de_la_nuit» : exprimée en heures ;
  • «Duree_plein_jour» : exprimée en heures. Cette valeur sera ajustée en fonction de l'effet désiré ;
  • «Luminosité_plein_soleil» : permet éventuellement de limiter la luminosité maximale ;
  • «Duree_fictive_de_la_minute» : plutôt que d'utiliser la fonction «wait ... milliseconds» on créé une minute fictive.
    Pendant la période de mise au point du programme on utilise une minute fictive courte. (≈ 10 ms)
    En utilisation normale, la minute fictive prendra une valeur plus élevée pour que le cycle complet ait la durée «à l'échelle» désirée (≈ 500 à 800 ms).

LES FONCTIONS PERSONNELLES
 
  • «Lever_du_jour» : cette fonction règle l'accroissement de l'intensité lumineuse du lever du jour ;
  • «Coucher_du_soleil» : règle la décroissance de l'intensité lumineuse en fin de journée ;
  • «Plein_jour» : maintient l'intensité lumineuse pendant la durée «Duree_du_jour» ;
  • «Nuit» : pendant la durée «Duree_de_la_nuit», l'intensité reste à son minima.

L'image ci-dessous montre cette structure préparée.​
Dans le corps du programme on a décrit le cycle jour-nuit en utilisant les «fonctions personnelles» créées mais non encore remplies : c'est simple ; c'est clair.
En fait, à ce stade, on a listé ce que DOIT faire le programme.
Il faut maintenant élaborer les différentes «fonctions personnelles» pour dire COMMENT le faire.
ARDUINO_ECLAIRAGE_JOUR-NUIT_1.png
LES FONCTIONS «HEURE» ET «MINUTE FICTIVE»

On construit aussi 2 fonctions pour gérer les durées :
  • «Attendre_une_minute», basée sur la variable «Duree_fictive_de_la_minute» ;
  • «Attendre_une_heure», càd 60 fois «Attendre_une_minute».

 
ARDUINO_ECLAIRAGE_JOUR-NUIT_2.png
«PLEIN_JOUR» et «NUIT» : LES PLUS FACILES
ARDUINO_ECLAIRAGE_JOUR-NUIT_3.png

Rien de spécial.
Chacune de ces fonctions génère une temporisation suivant le nombre d'heures qu'on a attribuées à «Duree_de_la_nuit» et à «Duree_plein_jour».

Ces deux fonctions n'agissent pas sur l'intensité lumineuse ⇒ pendant toute la durée de la temporisation, l'intensité lumineuse gérée par les 2 fonctions suivantes (ci-dessous) se maintient «en l'état».
 
FONCTIONS «Lever_du_jour» et «Coucher_du_soleil»
ARDUINO_ECLAIRAGE_JOUR-NUIT_4.png

Deux sœurs jumelles.

L'une fait croître l'intensité lumineuse, depuis «0» jusqu'à «Luminosite_plein_soleil».
L'autre la fait décroître de «Luminosite_plein_soleil» jusqu'à «0».

La fonction «Attendre_une_minute» permet de régler la rapidité de la croissance ou de la décroissance de l'intensité lumineuse.

Dans cet exemple, on utilise la sortie «3», qui donne un niveau de sortie analogique grâce à l'instruction
«set analog pin# 3 ...».

En réalité, «set analog pin# 3 ...» génère un signal PWM.

Note : c'est ce signal PWM qui sera utilisé pour commander un MOSFET de puissance, capable d'alimenter une lampe d'éclairage à LED.

 
LE PROGRAMME COMPLET
ARDUINO_ECLAIRAGE_JOUR-NUIT_5.png

Le cycle jour-nuit sera réglé en jouant sur les variables déclarées dans «Arduino run first».
 
  • «Duree_de_la_nuit» : logiquement entre 8 et 14 suivant qu'on veut simuler un cycle «été» ou un cycle «hiver» ;
  • «Duree_plein_jour» : plutôt entre 6 et 8 (et non pas «12» comme sur l'image ci-dessus) ;
  • «Luminosité_plein_soleil» : permet éventuellement de limiter la luminosité maximale.
    Le maxi est obtenu avec la valeur «255» ;
  • «Duree_fictive_de_la_minute» : plutôt que d'utiliser la fonction «wait ... milliseconds» on créé une minute fictive.

Avec «Duree_fictive_de_la_minute» = 10 le cycle est rapide.
Il ne dure environ 20 secondes.
Cette faible valeur permet de vérifier le fonctionnement du programme sans y passer trop de temps.

Avec 
«Duree_fictive_de_la_minute» = 500 le cycle jour-nuit complet dure de l'ordre de 16 minutes.
 
C'est sympa comme animation !
 
PETIT BONUS : LE MEME PROGRAMME AVEC L'ÉDITEUR PE6 PICAXE pour 08M2
ARDUINO_ECLAIRAGE_JOUR-NUIT_PICAXE.png
 
SIMULER LE JOUR ET LA NUIT
Complément :

Étage de puissance
Création : 02-12-2021 ; mise à jour : 03-12-2021

 
Pour permettre à Thibaut de réaliser concrètement son projet, voici la description de l'étage de puissance qui permettra de commander un éclairage à LED.

Cet étage de puissance est basé sur un transistor Mosfet IRF 540 qui fonctionne en commutation.
 
SCHÉMA «SORTIE DIRECTE»
INTENSITE_VARIABLE_SORTIE_MOSFET.png
C'est la solution la plus simple.

On choisira une lampe à LED du commerce qui fonctionne en 12 volts (ou des rubans à LED).


«J3» sera relié à la sortie «3» de l'ARDUINO, conformément au sketch.

«Vcc» sera fourni par une alimentation 12 V DC externe suffisamment puissante.
 
ATTENTION !
Il est impératif que le «Gnd» de l'ARDUINO soit relié à la masse de l'alimentation externe.
 
CYCLE_JOUR-NUIT-IRF540_2A.png

Note : TINKERCAD ne propose pas encore de composant spécifique «lampe à LED».
Cette lampe à LED est donc figurée par une lampe à filament.

 
SCHÉMA «SORTIE à OPTOCOUPLEUR»
INTENSITE_VARIABLE_SORTIE_MOSFET_SHARP_PC817.png
L'optocoupleur réalise une séparation galvanique entre L'ARDUINO et la tension 12 volts externe.

Ainsi, en cas de problème avec le transistor MOSFET, L'ARDUINO est protégé.

D'autres modèles d'optocoupleurs peuvent convenir :
Le montage ci-contre utilise un optocoupleur 4N35.

Plusieurs modèles d'optocoupleurs peuvent être utilisés :
  • PC 817 (DIL 4) ;
  • 4N35 (DIL 6) ;
  • IL 250 (DIL 6) ;
  • 6N137 (DIL 8) ;
  • ...
CYCLE_JOUR-NUIT-IRF540_2B.png

Note :
Ne pas tenir compte de l'indication de courant affichée par l'alimentation représentée sur les deux montages.


En réalité :
Si on utilise une lampe à LED de 7 watts, le courant s'établira à environ 600 mA.
Si on prévoit d'alimenter 3 lampes à LED de 7 watts, il faudra prévoir une alimentation 12 volts capable de délivrer 2 ampères.

 
Montage d'essai sous 5 volts
IMG_20211201_204158_th.jpg

Ci-contre, le montage de test.

On a utilisé une alimentation de 5 volts et un mini projecteur à  LED, qui fonctionne sous 5 volts :
«5V Led Light Panel Board White 9».
Looney_tunes.png
That's all Folks



 
 
FEUX de PÉNÉTRATION
Sympa pour créer des petites animations :
camions de pompiers, ambulances, voitures de police...


Le programme ci-dessous propose un type de fonctionnement :
x4 flash à droite ;
x4 flashs à gauche.
Création : 03-12-2021 ; mise à jour : 06-12-2021

Les feux de pénétration ne fonctionnent pas tous de façons identiques.
Cela dépend du type de véhicule.

Le programme proposé ci-dessous n'est qu'un exemple facile à adapter.
MONTAGE D'ESSAIS
FEUX_de_PENETRATION-2.gif
Fonction personnelle «Feu_de_droite»
FEU_de_PENETRATION_1.png

Très simple :
 
  • on allume la LED sur la sortie «3» pendant 50 millisecondes, puis on l'éteint pendant 50 ms et ceci 4 fois de suite ;
  • cette salve de 4 flashs est suivie par un temps d'attente de 300 ms, ceci pour espacer les salves droite et gauche.
     
FEU-de-PENETRATION-3.png
On va tout de suite améliorer cette fonction en créant des variables pour les différentes temporisations (instructions «wait... millisecondes»).
Ceci facilitera la mise au point pour obtenir l'effet optimal.
Tant qu'on y est, on mettra en place une variable pour le nombre d'éclats par salve.

FEU-de-PENETRATION-2.png
 
... et on installe ces variables dans «Arduino run first».

 

FEU-de-PENETRATION-4.png
 
Voici ce que devient la fonction personnelle «Feu_de_droite» équipée des variables.

 

FEU-de-PENETRATION-5.png
Par simple duplication on créé la fonction «Feu_de_gauche».
Il suffit de changer la sortie : «3» est remplacée par «4».
Le reste est inchangé.
Grâce aux variables déclarées dans «Arduino run first» toute modification de paramétrage sera reportée dans les deux fonctions.

 

FEU-de-PENETRATION-6.png
 
 
L'appel aux deux fonctions personnelles est mis en place dans «Arduino loop forever».

 

FEU-de-PENETRATION-7.png
 
Le programme est terminé.

 

emoticon_zen.png
Looney_tunes.png
 
That's all Folks !

 

 
Neons_2.jpg
SIMULATION D'ALLUMAGE
D'UN TUBE FLUORESCENT
Ce sera l'occasion d'utiliser deux nouvelles instructions :
 
  • «random integer...» pour générer des valeurs aléatoires ;
  • «repeat while...» pour attendre la survenue d'un événement.
Création : 03-12-2021 ; mise à jour : 06-12-2021

Les tubes fluorescents sont en passe de devenir «vintage».
Ils sont maintenant remplacés par des tubes à LED.
Pourtant rien ne nous empêche de les utiliser fictivement pour éclairer certains bâtiments qui agrémentent nos réseaux.
 
MONTAGE D'ESSAIS
ALLUMAGE_TUBE_FLUO_1.png

Pour simuler le tube fluorescent on utilise une LED (jaune ou blanc chaud).
Elle est connectée sur la sortie «3».

Un seul contact :
– il servira pour déclencher l'allumage puis l'extinction.
– il est relié à l'entrée «2».
 
But recherché

L'allumage d'un tube néon se déroule en deux phases : pendant quelques secondes le tube émet des éclats plus ou moins longs, avant de s'éclairer de façon stable.

C'est la première phase qui nous intéresse particulièrement : elle devra générer un nombre aléatoire d'éclats, d'intensité aléatoire et séparés par des intervalles de durée aléatoire.

C'est le rôle de la fonction random(x, y).
 
Opérateur mathématique «random()» : première approche

random() est un opérateur mathématique ⇒ on le trouve dans la catégorie Math.
 
ALLUMAGE_TUBE_FLUO_2.png

Ce bloc représente une valeur, comprise entre 0 et 100 inclus.
 

Dans un premier temps, nous allons l'utiliser pour générer une suite ininterrompue de niveaux lumineux sur la sortie n°3, d'une durée fixe de 500 millisecondes... juste pour voir comment fonctionne cet opérateur.
 
ALLUMAGE_TUBE_FLUO_3.png
confused-smiley.png
Ça marche ce truc ?
informatik.gif
Pas vraiment, non...
emoticone_confuse.jpg
Où est le problème ?
 
Examinons le fonctionnement du programme tel qu'il est construit ci-dessus :

À chaque tour dans la boucle «Arduino loop forever», random integer from [1 to 100] prend une valeur comprise entre 1 et 100, différente à chaque tour.

OK. Ça, on l'avait compris.

La LED sur la sortie analogique (PWM) va donc s'éclairer à des niveaux successifs compris entre 1 et 100.

Malheureusement, ce n'est pas très adapté à l'effet que l'on cherche à obtenir :
  • pour atteindre la luminosité maximale set analog pin 3 doit atteindre la valeur 255, et pas «100» ;
  • d'autre part, où est l'intérêt d'avoir 100 possibilités de niveaux d'éclairement, alors que 4 ou 5 suffisent ?
 
informatik.gif
Tu vois, je te l'avais dit...

 
emoticone_confuse.jpg
Ben, que peut-on faire ?
ALLUMAGE_TUBE_FLUO_4.png

Tout d'abord, réduire le nombre de niveaux possibles.
⇒ «5» est une valeur raisonnable.


 
confused-smiley.png
Oui.
Mais le niveau lumineux maximal sera égal à «5»...
C'est pas un peu faible ?


 
informatik.gif
Ben... il suffit de le multiplier par 50...

 
ALLUMAGE_TUBE_FLUO_5.png
L'opérateur «multiplication» se trouve dans la catégorie «Math».

C'est un bloc à options multiples auxquelles on accède grâce à un petit menu déroulant.


 
ALLUMAGE_TUBE_FLUO_6.png
On glisse «random int...» dans la première lumière (premier terme de la multiplication).

On glisse la valeur du multiplicateur dans la deuxième lumière (deuxième terme de la multiplication).
ALLUMAGE_TUBE_FLUO_7.png

Ainsi, la luminosité de la LED prendra 5 valeurs possibles, au hasard : 50, 100, 150, 200 et 250.



 
informatik.gif
Tu peux y aller : ça marche

 
emoticone_confuse.jpg
Oui, mais c'est un peu lent et un peu trop régulier...
«random()» peut s'appliquer au délai
ALLUMAGE_TUBE_FLUO_8.png

On duplique les blocs random int... et on modifie la valeur du multiplicateur.

Ce nouveau groupe de bloc est substitué à l'ancienne valeur «500» dans la fonction wait.

Ainsi les niveaux lumineux durent entre 20 et 100 millisecondes, au hasard.
 
emoticone_confuse.jpg
Bon, d'accord : c'est mieux.
Mais la phase de démarrage ne s'arrête jamais.

 
informatik.gif
OK...
... mais je voulais d'abord être sûr que tu as bien pigé ce qu'on peut attendre de l'opérateur «random».

 
Bâtir la séquence d'allumage
ALLUMAGE_TUBE_FLUO_9.png

Pour limiter le nombre d'éclats lumineux, il suffit d'inclure les deux groupes de blocs dans une boucle de comptage.



 
confused-smiley.png
Quelque chose me dit que ça ne va pas fonctionner...
 
informatik.gif
Bien sûr : ce n'est pas tout de générer 25 niveaux lumineux.
Encore faut-il que cette phase soit suivie par une phase d'allumage stable.


 
ALLUMAGE_TUBE_FLUO_10.png

Dans un premier temps, on limite cette phase d'allumage stable à environ 5 secondes.

Le programme répète indéfiniment un cycle :
  • phase d'allumage ;
  • allumage stable de 5 secondes.



 
emoticone_confuse_2.jpg
Ben moi, j'aimerais bien décider quand ça s'arrête !
 
informatik.gif
Jamais content...
 
Attendre l'appui sur un contact : fonction «repeat until...»

On pourrait imaginer utiliser la fonction test «if...» pour tester le contact sur l'entrée «2».

Cependant cette fonction n'est pas bloquante ⇒ si le test du bouton poussoir sur l'entrée 2 est faux (bouton non appuyé), cela n'empêche pas de repartir au départ du programme et de recommencer un cycle.

Par contre, la fonction repeat until [test] permet d'attendre indéfiniment que le poussoir soit enfin actionné.

repeat until [ ] est une fonction de boucle de répétition, donc elle se trouve dans la catégorie «Loops».

Le bloc propose 2 options : «while» et «until» :
  • while = «tant que...» ;
  • until = «jusqu'à ce que...»

 
ALLUMAGE_TUBE_FLUO_11.png

L'instruction wait [5000] et remplacée par la fonction repeat... qui teste l'état du contact sur l'entrée n°2.
 
 
 
 
 
 
 
 
 

On a réalisé un «FLIP-FLOP» :
  • premier appui ⇒ allumage ;
  • deuxième appui ⇒ extinction.
     
ALLUMAGE_TUBE_FLUO_12.png
Examinons le fonctionnement :

À la fin de la phase d'allumage, la LED s'éclaire de façon stable avec une luminosité de 250.

La boucle repeat[ ] tourne indéfiniment sans rien faire jusqu'à ce que le contact sur l'entrée n°2 bascule à l'état «LOW».
 
 
 
 
Emoticone_doute.jpg
Et maintenant,
ça fonctionne ?

 
informatik.gif
Ben non : dès  que le poussoir est activé, la LED s'éteint, mais... le programme redémarre instantanément.

 
Attendre l'appui sur un contact pour démarrer»
C'est la même fonction repeat until [ ] qui va permettre d'attendre indéfiniment l'appui sur le même contact pour démarrer l'application.
 
Elle sera logiquement placée avant la boucle repeat[ ].

On remarque que c'est le même contact qui est utilisé dans les deux cas : démarrage et arrêt.
 
ALLUMAGE_TUBE_FLUO_13.png
emoticone_confuse.jpg
Ben non.
Je viens d'essayer : ce n'est pas mieux !

 
informatik.gif
Je sais.
Il manque encore un petit truc...

 

Exact !

Lorsqu'on stoppe l'allumage avec la 2e boucle until[ ], on passe instantanément au début du programme, et donc à la première boucle until[ ].

... or on n'a pas eu le temps de relâcher le poussoir. Il est toujours à l'état «LOW» ⇒ la séquence d'allumage redémarre instannément.
 
smiley-got-idea.png
Je sais, je sais : il suffit d'ajouter un délai après la deuxième boucle until [ ]

 
informatik.gif
Gagné !
 
ALLUMAGE_TUBE_FLUO_14.png



On dispose maintenant d'une seconde pour relâcher le poussoir, sans risquer un redémarrage intempestif.











 
emoticone_confuse_2.jpg
C'est fini ?
 
informatik.gif
Presque.
 
Le programme complet
Tel qu'il est, ce programme fonctionne.

Cependant, on a fait une simplification hâtive sur la génération des éclats lumineux de la phase d'allumage.

En effet, les éclats lumineux sont en réalités séparés par des petits temps d'extinction complète, et on n'en a pas encore tenu compte.

 
informatik.gif
Maintenant que vous êtes des maître en opérations «random», ce qui suit va vous paraître évident...

 
ALLUMAGE_TUBE_FLUO_15.png



Chaque allumage aléatoire est suivi d'une extinction forcée de durée aléatoire.











 
Paramétrages
Pour s'amuser on peut maintenant jouer sur les paramètres des 3 différents opérateurs random.

On peut aussi modifier le nombre de répétitions de la boucle repeat 25 times.
 
Avec repeat 10 times on aura la simulation d'un tube fluo... récent.




... bon, ben disons «... un tube pas trop usagé». Ça va comme ça ?

Avec des temps d'extinctions plus longs (random integer 1 to 5 x 50), on simulera un néon qui a vraiment du mal à s'allumer.
 
Si on modifie set analog pin 3 to random integer from 1 to 5 x 50 en remplaçant «50» par «30» (par exemple), on aura une luminosité globale plus faible du néon : pratique pour ajuster la luminosité sans dessouder la résistance de limitation de la LED.

Attention tout de même : l'allumage stable devra en tenir compte : set analog pin 3 to 150 au lieu de 250.
 
informatik.gif
... et tu trouves ça drôle ?
Autre façon d'écrire le programme... pour le fun
Sur le fond, rien de changé.

Ce n'est qu'une question de forme : on répartit les différentes actions du programme dans des fonctions personnelles :
  • la boucle «Arduino loop forever» contient seulement la succession d'actions que doit accomplir le programme.
  • les fonctions expliquent comment le faire.

 
ALLUMAGE_TUBE_FLUO_16.png



Oui, on aurait pu aussi utiliser des variables pour y stocker les différents paramètres, mais dans un cas aussi simple, je ne suis pas certain que la clarté du programme en aurait été améliorée. 












 
Looney_tunes.png
 
That's all Folks !

 

 
soudure_arc-1.jpg
SIMULATION DE
SOUDURE À L'ARC
Ce sera l'occasion d'utiliser de nouveau les instructions :
 
  • «random integer...» pour générer des valeurs aléatoires ;
  • «repeat ...» pour générer les salves d'éclairs de l'arc électrique.
Download_1.png
Création : 17-12-2021 ; mise à jour : 17-12-2021
LE PROJET

L'idée est de simuler ce qui se passe quand un soudeur travaille :

  • une première phase plutôt courte qui correspond à la phase d'amorçage et de chauffe de la baguette de soudure ;
     

  • une phase longue qui correspond à la réalisation de la soudure des pièces ;
     

  • un temps d'attente de 6 à 18 secondes.
    Ainsi on a l'impression que le soudeur attend entre 6 et 18 secondes avant d'attaquer une nouvelle pièce à souder.

Pour obtenir un résultat réaliste, les éclairs de l'arc devront avoir une durée aléatoire et se succéder à intervalles aléatoires.

Leur nombre aussi sera aléatoire.

Ceci sera obtenu grâce à l'instruction mathématique «random integer from ... to ...».

SCHÉMA
ECLAIR_SOUDURE_A_L_ARC_7.png
FABRIQUER UN ÉCLAIR
ECLAIR_SOUDURE_A_L_ARC_1.png


C'est tout simplement un clignotant, mais dans lequel :

  • la durée d'allumage est aléatoire ;

  • la durée d'extinction est aléatoire.


Cependant, pour cet usage, l'instruction «random ...» est ici un peu... arrangée.
 

Explications :


On désire des durées d'allumage comprises entre 12 et 48 millisecondes (avec les paramètres de l'exemple ci-dessus), mais on ne veut pas toutes les durées possibles entre 12 et 48 ms.
On veut seulement 4 valeurs bien différentiées, échelonnées de 12 à 48 millisecondes.

 

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

ECLAIR_SOUDURE_A_L_ARC_2.png

 

  • «random integer from [ 1 ] to [ 4 ]» génère 4 valeurs différentes possibles : 1, 2, 3 et 4.

 

  • on utilise la fonction mathématique «multiplication» pour transformer ces 4 valeurs possibles de façon à obtenir pour les durées les 4 valeurs suivantes : 12, 24, 36 et 48.

De la même façon, l'instruction ci-dessous permet d'obtenir des temps d'extinctions de 8, 16, 24, 32 et 40 millisecondes.

ECLAIR_SOUDURE_A_L_ARC_3.png
FABRIQUER UNE SALVE COURTE

Une salve courte est constituée de quelques éclairs peu nombreux qui imitent les petits coups d'amorçage de l'arc que le soudeur fait pour échauffer la baguette de soudure.

On incorpore les blocs qui génèrent l'éclair défini ci-dessus dans une boucle «repeat ...», et on en profite pour créer une fonction personnelle «Salve_courte».


 

ECLAIR_SOUDURE_A_L_ARC_4.png

 

Ainsi paramétrée, la boucle «repeat ...» génère aléatoirement entre 2 et 8 éclairs d'affilée.

À la fin de chaque salve, la temporisation «wait 500 milliseconds» simule que le soudeur a relevé la baguette de soudure un très court instant, avant d'attaquer la vraie soudure.

FABRIQUER UNE SALVE LONGUE

La fonction personnelle «Salve_longue» est obtenue par duplication de la fonction «Salve_courte».

 

ECLAIR_SOUDURE_A_L_ARC_5.png

Une seule différence : le nombre de répétitions.

 

Cette fois, on est en plein travail de soudage ⇒ la séquence d'éclairs dure plus longtemps.

Ainsi paramétrée, «Salve_longue» produira aléatoirement de 3 x 15 = 45 à 8 x 15 = 120 éclairs d'affilée.

La temporisation «wait 500 milliseconds» simule une courte interruption (relevé de la baguette de soudure) en tre chaque salve longue.

LE CORPS DU PROGRAMME

 

  • il commande le déclenchement de 0 à 2 salves courtes pour simuler l'amorçage qui précède le soudage lui-même ;

  • il commande ensuite le déclenchement de 1 à 5 salves longues pour simuler la véritable phase de soudage ;

  • il génère une temporisation aléatoire de 6000 à 18000 millisecondes – c'est-à-dire de 6 à 18 secondes – pour simuler le temps qu'il faut pour passer à une autre pièce à souder.

ECLAIR_SOUDURE_A_L_ARC_6.png
BONUS

 

La luminosité de chaque éclair est donnée par l'instruction «set digital pin # 3 to HIGH».

L'extinction est obtenue avec l'instruction «set digital pin # 3 to LOW».

Tout ou rien.

En réalité, lors d'un soudage, les éclairs ne sont pas toujours à la luminosité maximale.

De même ils ne s'éteignent pas forcément complètement.

On va donc remplacer les instructions «set digital pin ...» par des instructions «set analog pin #3 to [  ]».

«set digital pin # 3 to HIGH» sera donc remplacée par :

H7XyjGA00a.png


La fonction «random...» génère 5 valeurs de luminosités possibles : 50, 100, 150, 200 et 250.

«set digital pin # 3 to LOW» sera remplacée par :

7GP4fTRxBO.png


ou bien...

Sp1QaDWr5i.png


La première fonction «random...» génère 4 valeurs de luminosités résiduelles possibles : 8, 12, 16 et 20.

La deuxième fonction «random...» génère 5 valeurs de luminosités résiduelles possibles : 40, 48, 56, 63 et 80.

Note : tous les paramètres peuvent être modifiés pour changer l'aspect de la séquence de soudage.

Voici les deux fonctions personnelles modifiées :

ECLAIR_SOUDURE_A_L_ARC_8.png
ECLAIR_SOUDURE_A_L_ARC_9.png
Super_1.jpg


Super !

informatik.gif


Oui.

Mais je suis sûr que tu n'as pas remarqué le petit additif ?

«set digital pin # 3 to LOW»


Eh oui !

La fonction «(random integer from 1 to 5) x 8» règle le niveau résiduel de luminosité de l'éclair mais ne l'éteint jamais complétement.

Or, si on veut que l'instruction «wait 500 milliseconds» procure un intervalle pendant lequel l'arc électrique est totalement arrêté, il est nécessaire que la sortie «3» soit forcée à l'état «LOW» juste avant cette temporisation.

C'est ce que réalise l'instruction «set digital pin # 3 to LOW».

Le corps du programme ne change pas.

Looney_tunes.png
That's all Folks !


 
 
Feu_de_camp_4.jpg
SIMULATION ULTRA SIMPLE
d'un FEU DE CAMP
Ce sera l'occasion d'utiliser de nouveau l'instruction :
 
  • «random integer...» pour générer des valeurs aléatoires ;
  • ... et un peu d'astuce.
Création : 18-12-2021 ; mise à jour : 18-12-2021
SCHÉMA DE BRANCHEMENT
Feu_de_camp_Tinkercad.png
Petit inventaire du matériel nécessaire :

x1 LED rouge ;
x1 LED orange ;
x2 résistances de 330 Ω.
x1 carte ARDUINO.
... mais pas de raton laveur... (cf. Jacques Prévert).


Note :
L'idéal est d'utiliser une LED bicolore rouge-jaune à cathode commune. Ainsi, la source lumineuse est moins encombrante que 2 LED côte à côte, et donc plus facile à loger sous le tas de branches du feu de camp.

 
LE CORPS DU PROGRAMME
Très très simple... et pourtant il donne un résultat très réaliste.

 
Feu_de_camp_blockly.png

Il n'est théoriquement pas simple de faire clignoter 2 LED indépendamment.
C'est le rôle du fonctionnement multi-tâches, qui est possible avec ARDUINO.

Nous allons éviter le multi-tâches, dont la complexité n'est pas du niveau débutant.


En trichant un peu, nous obtiendrons malgré tout un fonctionnement très réaliste avec peu d'efforts.
 
Gaston_2.jpg

«Avec peu d'efforts ?... » Ça me va... M'enfin !


 
«set analog pin# ... to ...»

Les LED rouge et jaune sont respectivement connectées sur les sorties 3 et 5, pour pouvoir utiliser l'instruction «set analog...».


 
Feu_de_camp_random_1.png
Feu_de_camp_random_2.png

Grâce à ces deux instructions les deux LED auront valeur de luminosité comprise aléatoirement entre 50 et 250, en 5 valeurs différentes possibles.

Par contre, ce qui est important, est que ces valeurs seront différentes d'une LED à l'autre.

 
Les instructions «wait ... »
Feu_de_camp_random_3.png

Les instructions «wait ... » génèrent, l'une et l'autre, 4 durées aléatoires de temporisation comprises entre 24 et 96 millisecondes.

Note :
Ces valeurs peuvent être adaptées pour modifier «l'effet de flame».

 
Fonctionnement

Comment fonctionne la boucle «Arduino loop forever» ?
 
  • la LED «3» s'allume à un niveau aléatoire calculé par l'instruction «random integer ... » ;
  • elle reste allumée à ce niveau pendant une durée aléatoire comprise entre 24 et 96 millisecondes ;
  • ensuite, c'est la LED «5» qui s'allume à un niveau aléatoire, différent de celui de la LED «3» ;
  • elle reste allumée à ce niveau pendant une durée aléatoire comprise entre 24 et 96 millisecondes, en 4 valeurs différentes possibles ;

Or le niveau lumineux de la LED «3» n'a pas encore été modifié.
⇒ la LED «3» reste donc allumée à son niveau pendant les deux temporisations.

Poursuivons...
 
  • le programme revient à la première instruction «set analog...» ;
  • la luminosité de la LED «3» est modifiée, mais pas celle de la LED «5» ;
  • la LED «3» reste à son niveau de luminosité pendant la temporisation aléatoire qui suit ;
  • la LED «5» voit alors sa luminosité modifiée ;
  • ...

⇒ la LED «5», elle aussi, est restée à son niveau de luminosité pendant 2 temporisations successives.
 
Mal_de_tete_3.jpg

T'avais dit «... sans efforts...»
 
informatik.gif
«... avec peu d'efforts...»
j'avais dit, mais un peu tout de même.
On n'est pas en vacances, là...

 
Pour résumer :
  • chaque LED reste allumée au même niveau de luminosité pendant deux temporisations ;
  • la luminosité des LED change alternativement : une fois l'une, une fois l'autre ;
  • les modifications de luminosité des LED ne sont pas indépendantes puisque pendant chaque nouvelle temporisation, les 2 LED conservent leur niveau respectif de luminosité ;
  • le phénomène se déroule assez rapidement ⇒ cette «non indépendance» ne se remarque pas.
 
C'est donc grâce à ce subterfuge qu'on obtient une simulation de feu de camp très réaliste, et avec seulement 4 instructions.
 
Looney_tunes.png
That's all Folks !


 

ARDUBLOCKLY : vraiment simple-2