Train d’impulsions

Le montage que je vous propose fait appel à un module Arduino, une DEL blanche et une résistance, 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 DEL. 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.

Figure 1

Les trains d’impulsions

L’aléatoire pour éviter la reproductibilité des flashes

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 DEL. 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. Avant d’aller plus loin, je vous invite à lire l’article « Comment gérer l’aléatoire ? » qui explique pourquoi et comment faire appel à l’aléatoire dans un programme.

Dans le langage Arduino, la fonction qui génère un nombre aléatoire est la fonction random. Elle est décrite à cette page.

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és 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/Rand...) 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 (dessinée avec Fritzing) montre le montage à réaliser : la résistance doit être choisie en fonction des caractéristiques de la DEL que vous utilisez. Pour calculer sa valeur, reportez-vous à l’article « Fonctionnement et pilotage d’une DEL ».

Figure 2

Le montage qui ne nécessite que trois composants

Le programme suivant fait fonctionner le montage. Les paramètres sont présentés dans les commentaires. Les valeurs mini et maxi peuvent être modifiées 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 1,5 et 7 s.
• nombre d’événements par cycle, compris entre 10 et 20
• durée du flash, compris entre 10 et 100 ms
• durée intermédiaire (LED éteinte), comprise entre 10 et 30 ms.

Bien entendu, vous pouvez choisir d’autres valeurs.

Voici le programme :

// 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
const byte Broche = 13 ;
const long Duree_flash_mini = 10 ;
const long Duree_flash_maxi = 101 ;
const long Duree_int_mini = 10 ;
const long Duree_int_maxi = 31 ;
const long Nbre_even_mini = 10 ;
const long Nbre_even_maxi = 21 ;
const long P_repos_mini = 1500 ;
const long P_repos_maxi = 7001 ;
    
// Fonction d'initialisation, nécessaire pour mise au point
void setup ()
{
  randomSeed (analogRead (0)) ;
  pinMode (Broche, OUTPUT) ;
}
     
// Corps du programme
void loop ()
{
  long Nbre_even = random (Nbre_even_mini, Nbre_even_maxi) ;
  for (long i = 1 ; i <= Nbre_even ; i++)
  {
    long Duree_flash = random (Duree_flash_mini, Duree_flash_maxi) ;
    long Duree_int = random (Duree_int_mini, Duree_int_maxi) ;
    digitalWrite (Broche, HIGH) ;
    delay (Duree_flash) ;
    digitalWrite (Broche, LOW) ;
    delay (Duree_int) ;
  }
  long P_repos = random (P_repos_mini, P_repos_maxi) ;
  delay (P_repos) ;
}

J’espère que cette application vous plaira et qu’elle agrémentera votre réseau.