Simulateur de soudure à l'arc
Pour simuler la lumière émise par un poste de soudure à l'arc, il suffit de commander une LED blanche haute intensité, comme on en trouve aujourd'hui dans les lampes torches, en la faisant s'allumer selon des flashes très courts, très rapprochés et se succédant de façon aléatoire.
C'est d'ailleurs le côté aléatoire des événements qui est difficile à reproduire avec de la logique câblée. Un tel montage avait été proposé dans Loco-Revue N° 603 de mai 1997 et il était basé sur trois circuits intégrés (plus quelques autres composants). Un des circuits fabriquait des trains d'impulsions à des fréquences différentes et ces signaux étaient ensuite autorisés ou non par un compteur décimal, à se recombiner entre eux grâce à des fonctions ET ou bien OU. C'était tout de même assez compliqué. :roll:
Le montage que je vous propose fait appel à un module Arduino, et une diode, et son comportement est réglable en fonction de vos goûts. La figure 1 montre un train d'impulsions émis par le programme, pour allumer la LED. Ce train d'impulsion est appelé cycle de soudure. Le cycle est constitué d'un certain nombre d'événements, chaque événement étant constitué d'un flash d'une certaine durée, suivi d'une période intermédiaire d'une certaine durée également, au cours de laquelle aucune lumière n'est émise. Entre deux cycles existe une période de repos, pendant laquelle le soudeur contrôle son travail ou bien positionne sa pièce autrement.
Notre programme permet de générer de façon aléatoire, les périodes entre deux cycles, pour chaque cycle le nombre d'événements, pour chaque événement les durées d'allumage et de repos de la LED. Le résultat est un comportement complètement aléatoire des trains d'impulsions. Tout est réglable de manière à obtenir le fonctionnement le plus crédible possible lié à une activité humaine, mais cela permet aussi d'avoir des comportements différents pour plusieurs postes de soudure à arc, si le montage est reproduit en plusieurs exemplaires sur le même réseau.
Chaque donnée générée par le programme de façon aléatoire, a sa valeur comprise entre une valeur minimum et une valeur maximum. C'est en jouant sur les valeurs minimum et maximum pour chaque paramètre, qu'on peut modifier le comportement de notre simulateur.
Dans le langage Arduino, la fonction qui génère un nombre aléatoire est la fonction random. Elle est décrite à cette page :
http://arduino.cc/en/Reference/Random
Nous l'utiliserons sous sa forme :
parametre = random (min, max) ;
parametre est alors compris entre min et (max - 1)
parametre, min et max doivent être déclaré de type long.
Dans un programme, les nombres aléatoires sont toujours générés à partir d'une valeur de départ (le seed). La fonction randomSeed (voir aussi http://arduino.cc/en/Reference/RandomSeed ) permet d'initialiser cette valeur de départ, par exemple randomSeed (valeur). Si valeur est une donnée fixe, à chaque fois qu'on lance (ou reset) le programme, celui-ci générera toujours la même suite de nombres aléatoires. Ce n'est pas très gênant (qui se rappellera de la suite ?), mais on peut faire mieux si valeur est aussi une donnée aléatoire. Ceci peut être obtenue par une lecture d'une entrée analogique laissée en l'air (non connectée) car elle aura tendance à capter les rayonnements parasites et donnera un peu n'importe quoi. L'initialisation se fait alors par :
randomSeed (analogRead (0)) ;
bien entendu, il faut laisser l'entrée analogique A0 en l'air.
La figure 2 montre le montage à réaliser :
Le programme suivant fait fonctionner le montage et permet de suivre la génération aléatoire des paramètres grâce au moniteur de l'environnement de développement d'Arduino. Les paramètres sont présentés dans les commentaires. Les valeurs mini et maxi peuvent être modifiés comme je l'ai expliqué. Les valeurs maxi doivent être égales à ce que vous voulez plus 1, à cause du comportement de la fonction random (voir un peu plus haut). Dans ce programme, ce n'est pas trop important de tenir compte de cela, mais je vous en parle si vous voulez utiliser random pour d'autres applications.
Les choix que j'ai initialement faits sont les suivants :
période entre deux cycles, comprise entre 3 et 10 s.
nombre d'événements par cycle, compris entre 5 et 10
durée du flash, compris entre 10 et 50 ms
durée intermédiaire (LED éteinte), comprise entre 10 et 30 ms.
Voici le programme :
Toute la partie affichage des nombres aléatoires est inutile une fois le montage installé sur votre réseau ; elle peut donc être supprimée. Le deuxième programme est donc la version qui génère les impulsions pour la LED sans faire aucun affichage ; les paramètres ont été changés à titre de comparaison et personnellement, je préfère ce nouveau comportement. :cheers:// Ce programme commande une LED blanche
// pour simuler un poste de soudure à l'arc.
// Il fait appel à la fonction random qui
// génère des nombres aléatoires.
// Duree_flash est la durée d'un flash.
// Duree_int est la durée entre deux flashes.
// Duree_flash et Duree_int forment un événement.
// Nbre_even est le nombre d'événements au cours
// d'un cycle de soudure
// P_repos est la durée entre deux cycles de soudure.
// Toutes ces données sont aléatoires mais bornées
// entre une valeur minimum et une valeur maximum.
// En jouant sur l'intervalle, on peut simuler au
// mieux l'effet de soudure à l'arc.
// Broche est la broche sur laquelle la LED est
// connectée.
// Initialisation des variables
byte Broche = 13 ;
long Duree_flash ;
long Duree_flash_mini = 10 ;
long Duree_flash_maxi = 51 ;
long Duree_int ;
long Duree_int_mini = 10 ;
long Duree_int_maxi = 31 ;
long Nbre_even ;
long Nbre_even_mini = 5 ;
long Nbre_even_maxi = 11 ;
long P_repos ;
long P_repos_mini = 3000 ;
long P_repos_maxi = 10001 ;
long i ;
// Fonction d'initialisation, nécessaire pour mise au point
void setup ()
{
Serial.begin (9600) ;
randomSeed (analogRead (0)) ;
delay (3000) ;
pinMode (Broche, OUTPUT) ;
}
// Corps du programme
void loop ()
{
Nbre_even = random (Nbre_even_mini, Nbre_even_maxi) ;
Serial.println (Nbre_even) ;
for (i = 1 ; i <= Nbre_even ; i++)
{
Duree_flash = random (Duree_flash_mini, Duree_flash_maxi) ;
Duree_int = random (Duree_int_mini, Duree_int_maxi) ;
Serial.print (Duree_flash) ;
Serial.print ("\t") ;
Serial.println (Duree_int) ;
digitalWrite (Broche, HIGH) ;
delay (Duree_flash) ;
digitalWrite (Broche, LOW) ;
delay (Duree_int) ;
}
P_repos = random (P_repos_mini, P_repos_maxi) ;
Serial.println (P_repos) ;
delay (P_repos) ;
Serial.println (" ") ;
}
Ce programme peut parfaitement être écrit dans une puce Attiny, programmée à partir d'un module Arduino qui sert de programmateur. Il convient simplement de bien choisir la sortie sur laquelle la LED est connectée, la puce Attiny ayant moins de sorties que le module Arduino !// Ce programme commande une LED blanche
// pour simuler un poste de soudure à l'arc.
// Il fait appel à la fonction random qui
// génère des nombres aléatoires.
// Duree_flash est la durée d'un flash.
// Duree_int est la durée entre deux flashes.
// Duree_flash et Duree_int forment un événement.
// Nbre_even est le nombre d'événements au cours
// d'un cycle de soudure
// P_repos est la durée entre deux cycles de soudure.
// Toutes ces données sont aléatoires mais bornées
// entre une valeur minimum et une valeur maximum.
// En jouant sur l'intervalle, on peut simuler au
// mieux l'effet de soudure à l'arc.
// Broche est la broche sur laquelle la LED est
// connectée.
// Initialisation des variables
byte Broche = 13 ;
long Duree_flash ;
long Duree_flash_mini = 10 ;
long Duree_flash_maxi = 101 ;
long Duree_int ;
long Duree_int_mini = 10 ;
long Duree_int_maxi = 31 ;
long Nbre_even ;
long Nbre_even_mini = 10 ;
long Nbre_even_maxi = 21 ;
long P_repos ;
long P_repos_mini = 1500 ;
long P_repos_maxi = 7001 ;
long i ;
// Fonction d'initialisation, nécessaire pour mise au point
void setup ()
{
randomSeed (analogRead (0)) ;
pinMode (Broche, OUTPUT) ;
}
// Corps du programme
void loop ()
{
Nbre_even = random (Nbre_even_mini, Nbre_even_maxi) ;
for (i = 1 ; i <= Nbre_even ; i++)
{
Duree_flash = random (Duree_flash_mini, Duree_flash_maxi) ;
Duree_int = random (Duree_int_mini, Duree_int_maxi) ;
digitalWrite (Broche, HIGH) ;
delay (Duree_flash) ;
digitalWrite (Broche, LOW) ;
delay (Duree_int) ;
}
P_repos = random (P_repos_mini, P_repos_maxi) ;
delay (P_repos) ;
}
Sonorisation du simulateur de soudure à arc
Hubert (HDE5962) m'a proposé quelques améliorations à apporter à mon simulateur de soudure à arc.La première, c'est de le sonoriser. Pour cela, il suffit de brancher un petit haut-parleur de 8 ohms sur la sortie 8 (par exemple) via une résistance de 100 Ohms, l'autre fil du haut-parleur étant relié à une sortie GND (masse) du module Arduino.
Dans le programme, il suffit de mettre la broche 8 en sortie, et de mettre cette broche à l'état HIGH ou LOW en même temps qu'on le fait pour la broche LED. Il y a donc quatre lignes de programme à rajouter (aux bons endroits bien sûr)
byte Broche_HP = 8 ; (dans l'initialisation)
pinMode (Broche_HP, OUTPUT) ; (dans le setup)
digitalWrite (Broche_HP, HIGH) ; (dans loop)
digitalWrite (Broche_HP, LOW) ; (dans loop)
Voilà votre simulateur qui reproduit de bruit du soudage !
la deuxième amélioration consiste à rendre un peu bleuté les éclairs émis, en fonction de vos goûts. il suffit de commander non pas une LED mais deux (une blanche haute intensité et une bleue) et de régler les intensités de chacune par l'intensité de courant qui la traverse (ou bien par un signal PWM réglé aléatoirement pour la LED bleue).
J'espère que cela vous inspirera ...
Christian
Page d'origine