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 «PLEIN_JOUR» et «NUIT»
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 le plus simple.

On choisira une lampe à LED du commerce qui fonctionne en 12 volts.


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

«Vcc» sera fourni par une alimentation 12 V DC externe.
 
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-dessous est par exemple représenté avec 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 de 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».
 
FONCTIONS «Allumage» et «Extinction» PROVISOIRES
ALLUMAGE_TUBE_FLUO_1A.png

Création de 2 fonctions personnelles :
  • «Allumage» ;
  • «Extinction».
Pour l'instant elles contiennent un ordre d'activation («High») ou de désactivation («LOW») de la sortie «3», mais surtout une temporisation de 500 millisecondes dont on verra bien tôt l'intérêt.
LE CORPS DU PROGRAMME
ALLUMAGE_TUBE_FLUO_2.png
Quel est l'objectif ?​
  • si on appuie fugitivement sur le poussoir de l'entrée «2», alors on appelle la fonction personnelle «Allumage» ;
  • si on appuie une nouvelle fois sur le poussoir, on appelle la fonction «set digital pin #3 = LOW».
Le même bouton poussoir sert à la fois pour allumer et pour éteindre.​
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 :
Tant que le poussoir n'est pas fugitivement appuyé, le programme parcourt les deux tests en permanence, à toute vitesse, sans rien faire.
On appuie sur le poussoir (entrée «2») ​⇒ immédiatement un des deux tests est activé.
Lequel ?
On ne peut pas déterminer lequel des 2 tests est en cours de traitement par le processeur au moment précis de l'appui sur le poussoir.
Aïe !
Supposons maintenant que, par hasard, ce soit le 1er test qui est traité au moment de l'appui sur le poussoir :
  • «Allumage» est activée, puisque le poussoir est appuyé (état «LOW») :
la LED sur la sortie «3» s'allume ;
⇒ grâce à la temporisation de 500 ms, on a eu le temps de relâcher le poussoir ;
⇒ le programme sort du 1er test.
  • le programme traite le 2e test. Or le poussoir est à l'état «HIGH» :
⇒ la fonction personnelle «Extinction» n'est donc pas activée ;
⇒ le programme sort du 2e test et se remet à tourner à toute vitesse.
Aïe !
informatik.gif
Tu vois, je te l'avais dit...

 
emoticone_confuse.jpg
Ben, que peut-on faire ?
ALLUMAGE_TUBE_FLUO_7A.png
Le programme doit rester «en attente d'un appui sur le poussoir» AVANT l'appel de la fonction «Allumage»,
pour être sûr que ce sera bien cette fonction qui sera activée lors du premier appui sur le poussoir.


Ceci est réalisé par une boucle «repeat until...» :

⇒ jusqu'à ce que l'entrée «2» devienne «LOW» (poussoir appuyé), on ne fait rien («do» est laissé vide).

Le programme ne quitte donc pas cette boucle tant qu'on n'actionne pas le poussoir.
 
ALLUMAGE_TUBE_FLUO_7B.png


Comme cette boucle d'attente va être utilisée plusieurs fois dans le programme, on créé tout de suite une fonction personnelle «Attendre jusqu'a l'appui sur le poussoir».

La lecture du programme en sera facilitée.







 
ALLUMAGE_TUBE_FLUO_7C.png
Le test fait double emploi.

En effet, c'est la boucle d'attente elle-même qui sert de test.
On n'en sort que lorsque le poussoir est actionné :
⇒ pas besoin de le tester une 2e fois.

⇒ suppression du test.
ALLUMAGE_TUBE_FLUO_7D.png
Récapitulons :
  • le programme attend AVANT la fonction «Allumage» ;
  • on appuie sur le poussoir ⇒ la fonction «Allumage» se déroule ;
le programme doit alors attendre AVANT l'appel de la fonction «Extinction», sinon la fonction «Extinction» ne sera jamais appelée.

Ceci est réalisé par la suppression du 2e test et un nouvel appel à la fonction «Attendre jusqu'a l'appui sur le poussoir».

On a réalisé un «FLIP-FLOP» :
  • premier appui ⇒ allumage ;
  • deuxième appui ⇒ extinction.
     
emoticone_confuse.jpg
Et maintenant,
ça fonctionne ?

 
informatik.gif
Oui.
Tu peux essayer.
LA FONCTION «Extinction»
ALLUMAGE_TUBE_FLUO_3.png
La voici telle qu'on l'a préparée à titre provisoire.





 
ALLUMAGE_TUBE_FLUO_3A.png

En fait, nous allons remplacer «set digital pin...» par 
«set analog pin# 3 to [0]».

Ceci est motivé par le fait que la fonction «Allumage» utilise une sortie analogique afin de disposer d'éclats d'intensité lumineuse variable.
 
LA FONCTION «Allumage»
ALLUMAGE_TUBE_FLUO_7E.png
La voici telle qu'on l'a préparée à titre provisoire.

Bien entendu, ainsi conçue, elle ne réalise qu'un allumage simple.



 
Comment doit se passer la séquence d'allumage de notre pseudo-néon, représenté par la LED ?

⇒ une douzaine d'éclats successifs, avant d'atteindre une intensité lumineuse stable :
 
ALLUMAGE_TUBE_FLUO_6A.png
informatik.gif
Essayez ceci : ça fonctionne...
... mais ce n'est pas génial !
emoticone_confuse.jpg
Ben oui !
Trop régulier, trop «tout ou rien».

 
Ce serait mieux :
  • si chaque éclat avait une durée aléatoire ;
  • si l'écart entre éclats avait une durée aléatoire ;
  • si l'intensité lumineuse de chaque éclat était variable d'un éclat à l'autre de façon aléatoire ;
  • et qu'au final, l'éclat de la LED se stabilise à la valeur maximale.
informatik.gif
C'est parti !
 
On va remplacer les valeurs numériques dans les instructions de la boucle «repeat [12] times» par des fonctions mathématiques aléatoires «random integer from [ x ] to [ y ]».

«random integer from [ x ] to [ y ]» génère un nombre entier compris entre x et y.

On va appliquer cette fonction – avec des paramétrages spécifiques – :
  • à la durée des éclats ;
  • à l'intervalle entre éclats ;
  • au niveau de luminosité des éclats, et entre éclats.
     
ALLUMAGE_TUBE_FLUO_7D.png
confused-smiley.png
Tu m'explique ?
 
informatik.gif
Assieds-toi et prends un verre...
Je t'explique la première fonction.

 
ALLUMAGE_TUBE_FLUO_7A.png
La fonction «random integer from 1 to 20» génère un nombre aléatoirement compris entre «1» et «20».

On n'a pas besoin de 254 valeurs différentes de luminosité pour les éclats.
ALLUMAGE_TUBE_FLUO_7B.png
ALLUMAGE_TUBE_FLUO_7.png

20 niveaux différents de luminosité suffisent très largement.
N'oublions pas que la boucle va générer seulement 12 éclats avant l'allumage complet.

Par contre on a besoin que l'intensité lumineuse maximale des éclats puisse atteindre un niveau proche du maximum (255).

⇒ si on insère la fonction «random» dans la fonction mathématique «[  ] x 12», les valeurs aléatoires possibles seront toujours au nombre de 20.

Mais au lieu d'être au hasard 1 ou 2 ou 3... ou 20, on obtiendra 12 ou 24 ou 36... ou 240 (ce qui est presque le maximum).

 

De même :
«(random integer from 1 to 30) x 4» permet d'obtenir :
  • 31 durées d'éclats différentes ;
  • avec des durées comprises entre 1 x 4 = 4, et 30 x 4 = 120 millisecondes.

«(random integer from 1 to 4) x 10» permet d'obtenir :
  • 5 niveaux bas de luminosité différentes, entre éclats ;
  • avec des niveaux compris entre 1 x 10 = 10, et 4 x 10 = 40.

«(random integer from 1 to 30) x 4» permet d'obtenir :
  • 31 durées entre éclats différentes ;
  • avec des durées comprises entre 1 x 4 = 4, et 30 x 4 = 120 millisecondes.

​En jouant sur les bornes des 4 fonctions «random...» et sur les facteurs multiplicatifs associés, on peut ajuster l'effet produit lors de l'allumage de notre pseudo-néon.
Si on porte le nombre d'éclats à 20 ou 30, on aura la simulation de l'allumage d'un néon quasi hors d'usage qu'on a oublié de remplacer.
 
LE PROGRAMME COMPLET
ALLUMAGE_TUBE_FLUO_7F.png
 
Le corps du programme (boucle «Arduino loop forever») est extrêmement dépouillé.
Il est très lisible.

Les fonctions sont individuellement simples, voir très simples.
 
Download_1.png
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

x1 LED rouge ;
x1 LED orange ;
x 2 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