Forums LR PRESSE

Où il est question de trains, petits et grands

  • Advertisement

Article Arduino de LR 798 (janvier 2014)

Toutes les discussions sur l'Arduino !

Modérateur: MOD

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Dim 29 Déc 2013, 19:04 
Une enseigne de commerçant à partir du montage publié dans Loco-Revue 798

Voici une nouvelle application, sans avoir à se fatiguer puisqu'on reprend le montage paru dans Loco-Revue N°798. :siffle:

Cette fois, en changeant uniquement le programme, nous allons obtenir une enseigne de commerçant. La couleur des LED importe peu, vous pouvez donc choisir ce que vous voulez ; pour ma part, j'ai choisi des LED vertes et le montage doit ressembler à ceci :

Image

Le clignotement d'une enseigne de commerçant n'obéit à aucune règle : toutes les fantaisies sont permises, alors autant ne pas se priver ! :gne: Vous pourrez donc modifier le programme que je vais vous donner pour faire à votre guise.

Pour ma part, mon enseigne réalise quatre séquences distinctes et pour chaque séquence, j'ai fait appel à une fonction. Le programme commence par éteindre toutes les LED et utilise pour cela une boucle for, telle qu'elle a été présentée plus haut dans ce forum (voir le chenillard).

Ensuite, l'enseigne flashe comme un chenillard trois fois de suite (c'est ce que j'ai nommé sequence_Un). Deux boucles imbriquées sont nécessaires : la première pour faire le chenillard trois fois de suite, la deuxième pour sélectionner les diodes à faire flasher.

Puis, l'enseigne allume successivement ses LED (lampes à l'échelle) en cumulant vers la gauche, ce qui permet d'écrire progressivement un nom de commerce (comme par exemple BISTRO ou bien GARAGE, selon vos centres d'intérêts ! :lol: ). C'est ce que j'ai appelé sequence_Deux.

Lorsque toutes les LED sont allumées, l'ensemble clignote trois fois grâce, encore à des boucles for imbriquées. C'est la sequence_Trois.

Enfin, les lettres de l'enseigne s'éteignent les unes après les autres, en partant de la gauche vers la droite. C'est la sequence_Quatre.

Le programme ressemble donc à ceci :

/*
Ce programme réalise le clignotement d'une enseigne publicitaire.
Il fait clignoter selon un certain rythme six LED reliées aux sorties 4 à 9.
Il utilise des fonctions pour alterner les rythmes.
*/

// Initialisation des lignes 4 à 9 en sortie
void setup () {
  pinMode (4, OUTPUT) ;
  pinMode (5, OUTPUT) ;
  pinMode (6, OUTPUT) ;
  pinMode (7, OUTPUT) ;
  pinMode (8, OUTPUT) ;
  pinMode (9, OUTPUT) ;
}

// Fonction loop
void loop () {
  // Extinction de toutes les LED au départ du programme
  for (byte i = 4 ; i <= 9 ; i++)
  {
    digitalWrite (i, LOW) ; // éteint la LED reliée à la broche i
  }
  
  // Séquence N°1 ; chenillard
  sequence_Un () ;
  delay (500) ; //delai de 500 millisecondes

  // Séquence N° 2 : cumul sur la gauche du mouvement de LED
  sequence_Deux () ;
  delay (500) ; // délai de 500 millisecondes
  
  // Séquence N°3 : clignotement de l'ensemble 3 fois
  sequence_Trois () ;
  delay (2000) ; // délai de 2 secondes

  // Séquence 4 : extinction successive de la gauche vers la droite
  sequence_Quatre () ;
  delay (2000) ;
  
  // Recommence la séquence
}

void sequence_Un ()
{
  // Séquence N°1 ; chenillard
  
  for (byte n = 0 ; n <= 2 ; n++)
  {
    for (byte i = 4 ; i <= 9 ; i++)
    {
      digitalWrite (i, HIGH) ; // allume la LED sur broche i
      delay (100) ; // durée du flash 150 millisecondes
      digitalWrite (i, LOW) ; // éteint la LED
      delay (50) ;
    }
  }
  return ;
}

void sequence_Deux ()
{
  // Séquence N° 2 : cumul sur la gauche du mouvement de LED
  
  for (byte n = 0 ; n <= 5 ; n++)
  {
    for (byte i = 4 ; i <= (9-n) ; i++)
    {
      digitalWrite (i, HIGH) ; // allume la LED sur broche i
      delay (150) ; // durée du flash 150 millisecondes
      digitalWrite (i, LOW) ; // éteint la LED
    }
    digitalWrite ( (9 - n) , HIGH ) ; //dernière LED reste allumée
  }
  return ;
}

void sequence_Trois ()
{
  // Séquence N°3 : clignotement de l'ensemble 3 fois
  
  for (byte j = 1 ; j <= 3 ; j++)
  {
    for (byte k = 4 ; k <= 9 ; k++)
    {
      digitalWrite (k , LOW) ;
    }
    delay (500) ;
    for (byte l = 4 ; l <= 9 ; l++)
    {
      digitalWrite (l, HIGH) ;
    }
    delay (500) ;
  }
  return ;
}

void sequence_Quatre ()
{
  // Séquence 4 : extinction successive de la gauche vers la droite
  
  for (byte i = 9 ; i >= 4 ; i--)
  {
    digitalWrite (i, LOW) ;
    delay (150);
  }
  return ;
}
 
  



:idea: :arrow: :arrow: :arrow:

Les fonctions que j'ai crées réalisent une tâche (une séquence d'allumage) et ne retournent aucun argument. Elles sont définies de type void, portent un nom (ex sequence_Un), et les instructions à réaliser sont entre deux accolades (comme pour la fonction loop). Néanmoins, à la différence de loop, les fonctions se terminent par « return ».

Le programme exécute les instructions contenues dans loop. Lorsqu'il arrive sur une fonction, il va chercher les instructions définissant la fonction et les exécute dans l'ordre. Arrivé à « return », il sait qu'il a fini, alors il reprend le programme contenu dans loop, là où il s'était arrêté.

Bien sûr, ceci n'est qu'un exemple. Vous pouvez maintenant créer vos propres fonctions pour définir d'autres séquences d'allumage (va et vient, allumage aléatoire, chenillard à chaque extrémité se rejoignant au centre et rebondissant vers les extrémités, etc.) :geek:

Et si vous hésitez entre les feux, le chenillard ou l'enseigne, n'allez surtout pas acheter d'autres modules Arduino : il est possible de faire tenir les trois montages sur un seul module, comme le montre la vidéo postée plus haut dans ce forum :

https://vimeo.com/82468022

Dans cette vidéo, la couleur des LED de l'enseigne est rouge ; cela collait mieux avec le mot bistro, mais j'aurais pris des LED bleues si j'avais écrit garage ! J'aurais même pris toutes les couleurs pour écrire Toys R Us, vous savez, ce magasin de jouets où on ne trouve pas (ou peu) de trains électriques ! :siffle:

Nous reparlerons du programme de la vidéo une prochaine fois, ce qui vous laisse le temps pour réfléchir à la façon de faire (en utilisant la fonction delay, sinon c'est trop facile).

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Dim 29 Déc 2013, 21:03 
Bonsoir,
Je lis pour l'instant un peu "en diagonale" les articles sur Arduino, car pour l'instant j'en suis à dessiner des plans de réseau. Mais je pense automatiser le gare souterraine de mon projet, et ce système sera certainement mis à contribution.
Aussi ma question ne sera peut-être pas forcément pertinente, pardon par avance si cela est.

Dans le programme donné page 105 de LR798, je suppose que la commande "void loop" correspond au début du programme qui sera effectué en boucle ?

Or ce qui me chagrine, c'est que la première série d'instructions de cette boucle éteint toutes les LED (digitalWrite (<lampe><couleur>, LOW).

Ces instructions ne devraient-elles pas se trouver dans la partie initialisation ?

Cordialement.
Jihel
Jihel
Papotier
 
Messages: 167
Inscrit le: Sam 25 Oct 2008, 09:52
Localisation: Plouézec 22
Âge: 65
Echelle pratiquée: HO ; N

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Lun 30 Déc 2013, 00:23 
Bonsoir Jihel,

L'Arduino sera parfait pour automatiser votre gare souterraine.

Votre remarque est juste. L'extinction des LED peut tout-à-fait se trouver dans la partie initialisation, donc dans la fonction setup, plutôt que dans la fonction loop.

Je l'ai mise dans loop pour qu'à chaque début de boucle (loop), on parte d'une situation nette, ceci pour éviter que des LED puissent rester allumées suite à des interférences électromagnétiques (rayonnement de portable, ou autre).

Cet excès de précaution n'est peut-être pas justifié, mais vu les quelques microsecondes perdues pour l'extinction des LED, cela ne change pas grand chose de le faire plusieurs fois dans loop plutôt qu'une seule fois dans setup.

Ce qui est remarquable, c'est que plusieurs façons de programmer peuvent donner le même résultat. Pour ce premier programme, mon but était aussi pédagogique et l'optimisation du code n'était pas ma préoccupation ; je voulais montrer à des débutants que l'on peut programmer comme on écrit. Dans ces forums sur Arduino, vous verrez des exemples d'optimisation de code ; cela viendra naturellement au fur et à mesure que vous programmerez Arduino.

A votre disposition pour répondre à d'autres interrogations.

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Ven 03 Jan 2014, 15:59 
Trois animations lumineuses sur un module Arduino Uno

Maintenant que vous avez réalisé vos trois animations lumineuses (feux tricolores, chenillard et enseigne de commerçant), je vous propose aujourd'hui de les réunir sur un même module Arduino. Vous obtiendrez donc un montage identique à celui de la vidéo postée plus haut dans ce forum :

https://vimeo.com/82468022

Cette fois, il est nécessaire de refaire le montage, pour la simple raison qu'il y a trois fois 6 LED à commander. Mais comment relier 18 LED à nos sorties numériques qui ne sont que 14 (de 0 à 13) ?

Il faut savoir que les entrées analogiques (A0 à A5) peuvent être utilisées comme sorties numériques (dans ce cas, on les numérote de 14 à 19), ce qui porte à 20 le nombre de sorties.

Les 6 LED formant l'enseigne sont reliées aux sorties 2 à 7 ; la couleur est à votre choix.
Les 6 LED formant le chenillard sont reliées aux sorties 8 à 13 ; la couleur est jaune ou orange (feux de travaux).
Le feu A1 est relié aux sorties 14 à 16 (A0 à A2) ; LED verte en 14, orange en 15 et rouge en 16.
Le feu B1 est relié aux sorties 17 à 19 (A3 à A5) ; LED verte en 17, orange en 18 et rouge en 19.

Voyons pour la consommation de courant, qui est limitée à 200 mA pour le module. Le feu tricolore allume deux LED en même temps (il consomme donc 40 mA), le chenillard n’allume qu’une seule LED à la fois (il consomme 20 mA), l’enseigne lumineuse peut allumer toutes les LED en même temps ; elle consomme donc 120 mA et la consommation totale des trois montages peut être de 180 mA, ce qui est très proche des possibilités du module !

Cela passe, mais si vous voulez garder une petite marge de sécurité, la solution la plus simple consiste à limiter le courant à 15 mA par LED pour l'enseigne de commerçant qui consomme le plus. C'est la solution que j'ai adoptée ; les résistances sont égales à 150 ohms pour les LED des feux et du chenillard, et à 220 ohms pour les LED de l'enseigne.

Le montage ressemble donc à cela :

Image

Voyons un peu le programme. Le but (pédagogique) est de réunir trois applications dans un seul programme. Il n'est donc pas question de changer les programmes déjà écrits, on doit s'en inspirer. Seulement ces programmes utilisent la fonction delay qui consomme beaucoup de temps (le microcontrôleur ne peut rien faire d'autre pendant que delay s'exécute.

L'allumage ou l'extinction d'une LED est quasiment instantané (quelques microsecondes) ; ces actions très rapides sont à intercaler entre d'autres actions. On peut régler les feux lorsque c'est nécessaire et pour cela, il faut se fixer une unité de base de temps. Le plus simple est de prendre une seconde et de choisir que le chenillard soit lancé toutes les secondes. Avant chaque lancement du chenillard, on manipule une LED de l'enseigne, selon la séquence choisie (cette fois on ne fait plus appel aux fonctions). La première séquence de l'enseigne est le cumul sur la gauche ; lorsqu'elle est terminée, le temps écoulé est de 22 secondes. Il est alors temps de faire passer à l'orange le feu qui était vert. La durée du feu orange, dure le temps de la séquence 2 (clignotement de l'ensemble des LED de l'enseigne deux fois car trois aurait donné une durée de feu orange trop forte). Lorsque la séquence 2 est terminée, le feu doit passer au rouge. On lance alors la dernière séquence de l'enseigne (l'extinction de la gauche vers la droite), ce qui permet la temporisation du chauffard ; puis l'autre feu passe au vert, et un deuxième cycle recommence à l'identique pour le feu B1.

Bien sûr, il ne faut pas oublier de lancer le chenillard toutes les secondes. La fonction « chenillard » a été créée pour cela. Chaque LED s'allumant 50 ms (T2), la durée totale du chenillard est de 300 ms (6 fois T2). Pour le déclencher toutes les secondes, on introduit un délai égal à 700 ms (T1).

En choisissant T1 = 700 ms et T2 = 50 ms, le chenillard est lancé toutes les secondes, la durée du vert est de 22 s, celle de l'orange de 4 s et celle du rouge 27 s (22 + 4 + 1 qui est la temporisation du chauffard).

Voici le programme :

/*-------------------------------------------------------
Ce programme fait fonctionner une enseigne lumineuse,
un chenillard et des feux tricolores, en même temps.
Six LED rouges sont reliées aux sorties 2 à 7 et 
forment l'enseigne.
Six LED jaunes sont reliées aux sorties 8 à 13 et
forment le chenillard.
Les sorties analogiques sont utilisées comme sorties 
numériques et sont numérotées 14 à 19.
Les sorties 14 à 16 forment le feu A1.
Les sorties 17 à 19 forment le feu B1.
T2 est la durée d'un flash du chenillard en ms.
La durée du chenillard est 6 fois T2 en ms.
Pour que le chenillard soit déclenché toutes les secondes, 
il faut que (T1 + 6 fois T2) soit égal à 1000 ms
En jouant sur T1 et/ou T2, on dynamise le rythme
Par exemple, pour T1 = 700 et T2 = 50, on a :
Vert : 22 secondes
Orange : 4 secondes
Rouge : 27 secondes (car temporisation du chauffard 1 sec)
--------------------------------------------------------*/

// Initialisation des variables

const byte A1V = 14 ;
const byte A1O = 15 ;
const byte A1R = 16 ;
const byte B1V = 17 ;
const byte B1O = 18 ;
const byte B1R = 19 ;
const int T1 = 700 ; // Fixe le rythme de déclenchement du chenillard
const int T2 = 50 ; // Durée du flash du chenillard
// T1 + 6 fois T2 doit être égal à 1000 !


void setup ()
{
  // Initialisation de toutes les lignes en sortie
  for (byte i = 2 ; i <= 19 ; i++)
  {
    pinMode (i, OUTPUT) ;
  }
  
  // Extinction de toutes les LED au départ
  for (byte j = 2 ; j <= 19 ; j++)
  {
    digitalWrite (j, LOW) ;
  }
  
  // Allumage de A1V et B1R
  digitalWrite (A1V, HIGH) ;
  digitalWrite (B1R, HIGH) ;
  
}

// Fonction loop
void loop ()
{
  // Début de cycle ; le feu A1 est vert et le feu B1 est rouge
  // L'enseigne cumule vers la gauche
  for (byte n = 0 ; n <= 5 ; n++)
  {
    for (byte m = 2 ; m <= (7 - n) ; m++)
    {
      digitalWrite (m, HIGH) ;
      delay (T1) ;
      chenillard () ;
      digitalWrite (m, LOW) ;
    }
    digitalWrite ((7 - n), HIGH) ;
  }
  delay (T1) ;
  chenillard () ;
  // On est à 22 secondes
  // Feu A1 passe à orange
  digitalWrite (A1V, LOW) ;
  digitalWrite (A1O, HIGH) ;
  // Enseigne clignote dans sa totalité deux fois
  for (byte j = 1 ; j <= 2 ; j++)
  {
    for (byte k = 2 ; k <= 7 ; k++)
    {
      digitalWrite (k, LOW) ;
    }
    delay (T1) ;
    chenillard () ;
    for (byte l = 2 ; l <= 7 ; l++)
    {
      digitalWrite (l, HIGH) ;
    }
    delay (T1) ;
    chenillard () ;
  }
  // On est à quatre secondes
  // Feu A1 passe au rouge
  digitalWrite (A1O, LOW) ;
  digitalWrite (A1R, HIGH) ;
  // Enseigne s'éteint de la gauche vers la droite
  // Le temps nécessaire pour cela constitue la temporisation du chauffard
  for (byte i = 7 ; i >= 2 ; i--)
  {
    digitalWrite (i, LOW) ;
    delay (T1/6) ;
  }
  chenillard () ;
  // On est à une seconde, le rouge a donc duré 22 + 4 + 1 = 25 sec
  // Feu B1 passe au vert
  digitalWrite (B1R, LOW) ;
  digitalWrite (B1V, HIGH) ;
  // Le feu A1 est rouge et le feu B1 est vert
  // L'enseigne cumule vers la gauche
  for (byte n = 0 ; n <= 5 ; n++)
  {
    for (byte m = 2 ; m <= (7 - n) ; m++)
    {
      digitalWrite (m, HIGH) ;
      delay (T1) ;
      chenillard () ;
      digitalWrite (m, LOW) ;
    }
    digitalWrite ((7 - n), HIGH) ;
  }
  delay (T1) ;
  chenillard () ;
  // Feu B1 passe à l'orange
  digitalWrite (B1V, LOW) ;
  digitalWrite (B1O, HIGH) ;
  // Enseigne clignote dans sa totalité deux fois
  for (byte j = 1 ; j <= 2 ; j++)
  {
    for (byte k = 2 ; k <= 7 ; k++)
    {
      digitalWrite (k, LOW) ;
    }
    delay (T1) ;
    chenillard () ;
    for (byte l = 2 ; l <= 7 ; l++)
    {
      digitalWrite (l, HIGH) ;
    }
    delay (T1) ;
    chenillard () ;
  }
  // Feu B1 passe au rouge
  digitalWrite (B1O, LOW) ;
  digitalWrite (B1R, HIGH) ;
  // Enseigne s'éteint de la gauche vers la droite
  // Le temps nécessaire pour cela constitue la temporisation du chauffard
  for (byte i = 7 ; i >= 2 ; i--)
  {
    digitalWrite (i, LOW) ;
    delay (T1/6) ;
  }
  chenillard () ;
  // Feu A1 passe au vert
  digitalWrite (A1R, LOW) ;
  digitalWrite (A1V, HIGH) ;
  // Le feu A1 est vert, le feu B1 est rouge, le cycle peut recommencer
}
  
void chenillard ()
{
  // Boucle pour faire flasher les LED du chenillard, durée 300 ms
  for (byte i = 8 ; i <= 13 ; i++)
  {
    digitalWrite (i, HIGH) ; // allume la LED sur broche i
    delay (T2) ; // durée du flash 50 millisecondes
    digitalWrite (i, LOW) ; // éteint la LED
  }
  return ;
}
 
    



Maintenant que vous connaissez les astuces pour commander les trois animations, vous pouvez remarquer, sur la vidéo, qu'on voit bien que c'est le rythme de l'enseigne qui fixe le rythme des feux. Ceci est dû au fait que les trois animations sont proches l'une de l'autre sur la breadboard. Une fois que les animations seront en place sur votre réseau, cela ne se remarquera plus, car l'observateur fixera une animation à la fois, en fonction des saynètes que vous développerez.

Bien sûr, il y a d'autres façon d'arriver au même résultat, notamment en utilisant la fonction millis. Si la programmation vous intéresse, c'est sans doute un bel exercice à réaliser. Si vous souhaitez simplement disposer de trois animations lumineuses sur votre réseau pour un prix défiant toute concurrence, vous avez le plan de câblage et le programme. :gne:

Amusez-vous bien ! :siffle:

Arduinotement vôtre.

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Jeu 09 Jan 2014, 13:16 
Animation lumineuse de fête foraine

Maintenant que vous avez réalisé vos premières animations lumineuses pour votre réseau (feux tricolores, chenillard, enseigne de commerçant : voir plus haut), je vous propose aujourd'hui un montage qui vous permettra de recréer des animations lumineuses colorées et clignotantes des fêtes foraines. :moi:

Je vous invite à vous reporter au montage du chenillard décrit plus haut. Dans un chenillard, chaque LED est commandée individuellement pour la faire flasher, ce qui permet de créer un mouvement de lumière qui se propage d'une LED à l'autre. Le principe est le même pour une fête foraine, mais comme il faut beaucoup de LED, on commande des rampes de LED. :wink:

J'ai expliqué dans LR 798 comment il était possible de commander plusieurs LED avec Arduino (reportez-vous à la figure 2 de l'article :gne: ). Le montage, qui fait appel à un simple transistor, serait à construire en autant d'exemplaires qu'il y a de rampes de LED à commander. C'est moins fastidieux (et meilleur marché) de faire appel à un circuit intégré ULN2803, qui contient huit transistors et permet ainsi de commander 8 rampes de LED.

Le montage que je vous propose aujourd'hui va vous permettre de commander 5 rampes, constituées de 5 LED :noel: . La couleur des LED est indifférente, il suffit seulement d'adapter la résistance de limitation de courant en fonction de la couleur (voir le calcul très simple dans LR 798 page 103). Le nombre de LED par rampe est limité à 5 car les rampes sont alimentées en 12 V continu, tension qu'on trouve facilement sur un réseau, mais vous pouvez utiliser une tension plus forte (24 V par exemple) pour augmenter le nombre de LED par rampe. La première rampe est de couleur verte et elle est commandée par la sortie numérique 0 d'Arduino, les autres rampes sont jaunes et sont commandées par les sorties 1 à 4. Les LED des différentes rampes sont disposées selon un motif répétitif (1, 2, 3, 4, 5, 1, 2, etc. : voir schéma) afin de créer une guirlande en quelque sorte, qui pourra serpenter le long d'une attraction foraine. Voici le schéma de montage réalisé sur deux breadboards (toutes les LED ont leur anode à gauche) :

Image

Le premier programme permet d'allumer les rampes les unes après les autres, ce qui crée un mouvement de lumière, plusieurs flashes se propageant le long de la guirlande. Pour bien voir le mouvement, clignez un peu des yeux ou bien disposez un papier calque devant vos LED. Voici le programme :

// Ce programme contrôle cinq rampes de LED 
// Chaque rampe contient 5 LED d'une même 
// couleur, et est alimentée en 12 V.
// Les sorties 1 à 5 d'un ULN2803
// commandent chacune une rampe.
// Les entrées 1 à 5 de l'ULN2803
// sont reliées aux sorties 0 à 4 d'un module
// Arduino Uno.
// L'animation lumineuse recrée un chenillard
// et imite les lumières de fêtes foraines

// Initialisation des variables
byte i = 0 ;

// Initialisation des cinq lignes en sortie
// et extinction des cins rampes 3 secondes
void setup () {
  for (i = 0 ; i < 5 ; i++){
    pinMode (i, OUTPUT) ;
  }
  for (i = 0 ; i < 5 ; i++){
    digitalWrite (i, LOW) ;
  }
  delay (3000) ;
}

// Programme faisant cheminer des flashes
void loop () {
  for (i = 0 ; i < 5 ; i++){
    digitalWrite (i, HIGH) ;
    delay (80) ;
    digitalWrite (i, LOW) ;
    delay (25) ;
  }
}



En fait, dans les fêtes foraines, les manèges sont les plus lumineux possibles, afin d'attirer les badauds ; plutôt que de faire cheminer un flash parmi des lampes éteintes, on préfère faire cheminer une ombre parmi des lampes allumées. Le mouvement des ombres qui se propagent de lampe en lampe crée l'animation dans un manège éclairé au possible. C'est ce que réalise ce deuxième programme :

// Ce programme contrôle cinq rampes de LED 
// Chaque rampe contient 5 LED d'une même 
// couleur, et est alimentée en 12 V.
// Les sorties 1 à 5 d'un ULN2803
// commandent chacune une rampe.
// Les entrées 1 à 5 de l'ULN2803
// sont reliées aux sorties 0 à 4 d'un module
// Arduino Uno.
// L'animation lumineuse recrée un chenillard
// et imite les lumières de fêtes foraines

// Initialisation des variables
byte i = 0 ;

// Initialisation des cinq lignes en sortie
// et allumage des cinq rampes 3 secondes
void setup () {
  for (i = 0 ; i < 5 ; i++){
    pinMode (i, OUTPUT) ;
  }
  for (i = 0 ; i < 5 ; i++){
    digitalWrite (i, HIGH) ;
  }
  delay (3000) ;
}

// Programme faisant cheminer des ombres
void loop () {
  for (i = 0 ; i < 5 ; i++){
    digitalWrite (i, LOW) ;
    delay (80) ;
    digitalWrite (i, HIGH) ;
  }
}



Voilà, j'espère que cette nouvelle application vous plaira et que vous vous en inspirerez pour créer d'avantages de rampes lumineuses. Imaginez un module Arduino Mega 2560 dont les 70 lignes commanderaient autant de rampes : de quoi éclairer toute une fête foraine ! :clown: N'est-ce-pas ce qui était décrit dans le forum « Arduino et le projet APTE » page 28, Le monde selon Arduino (voir viewtopic.php?f=63&t=74127&start=405 ). :moi:

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mar 14 Jan 2014, 18:40 
Schéma et vidéo pour l'animation lumineuse de fête foraine

Pour ceux qui préfèrent les schémas électroniques plutôt que les plans de montage sur breadboard, voici celui de l'animation lumineuse de fête foraine :

Image

Les valeurs des résistances R1 à R5 dépendent de la couleur des LED, donc de la tension aux bornes de celles-ci. Pour ma part, j'utilise des LED vertes pour la rampe N°1 et jaunes pour les autres rampes. Toutes les rampes sont alimentées en 12 V. Dans ces conditions, mes résistances sont égales à :
R1 = 100 ohms (marron, noir, marron)
R2 = R3 = R4 = R5 = 220 ohms (rouge, rouge, marron)
Ces valeurs peuvent être adaptées en fonction de la luminosité désirée. :wink:

Voici maintenant une petite vidéo montrant les effets obtenus avec les deux programmes listés plus haut :

https://vimeo.com/84134325

Bien entendu, vous pouvez, avec ce montage, imaginer d'autres effets lumineux pour chacune de vos rampes de LED, comme on peut en voir avec les guirlandes de Noël qui fonctionnent sur le même principe, avec un micro-contrôleur. :gne:

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 07:20 
Tant qu'à jouer avec des LEDs, j'ai enfin terminé les dernières illuminations pour ma chère épouse :

http://www.youtube.com/watch?feature=pl ... 8hrxd72H2E

Près de 500 soudures, et de toutes petites, à tel point que j'ai du acheter un fer bien pointu... dont la pointe s'est bouffée en 50 soudures. Finalement je suis revenu à mon vieux Weller 60W thermorégulé, avec une panne plus fine.

J'ai gagné un bisou :coeur1:
Avatar de l’utilisateur
Ramboman
Disert
 
Messages: 423
Inscrit le: Lun 23 Oct 2006, 18:13
Localisation: Waterloo, Belgique
Âge: 73
Echelle pratiquée: LGB

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 10:48 
La différence entre les cubes 8 X 8 X 8 colorés et les "jouets" que je propose, c'est que ces derniers ont une application pour le modélisme ferroviaire ! :wink:

C'est bien le but d'un forum sur les trains miniatures, non ? Parler de ce qui concerne les trains ! Pour les autres sujets, il y a d'autres forums ... :roll:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 10:57 
Pour ceux qui n'ont pas peur de se ridiculiser en "jouant" avec des LED, je compte vous proposer une dernière application pour vos réseaux de trains. Ceci nous permettra d'évoquer quelques fonctions nouvelles du langage Arduino et de voir comment concevoir le montage (et sa supériorité par rapport au même montage réalisé en logique câblée). :wink:

Ensuite, nous aurons fait le tour de tout ce qui utilise des LED sur un réseau de trains. J'attendrai alors la parution de mon prochain article pour changer de registre.

Juste un peu de patience ... Cela devrait vous plaire ... :coeur1:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 11:12 
Arduino a écrit:La différence entre les cubes 8 X 8 X 8 colorés et les "jouets" que je propose, c'est que ces derniers ont une application pour le modélisme ferroviaire ! :wink:

C'est bien le but d'un forum sur les trains miniatures, non ? Parler de ce qui concerne les trains ! Pour les autres sujets, il y a d'autres forums ... :roll:


M'enfin, c'est pour décorer sa fête foraine, à côté de sa grande roue... et ça fait plein de lols... on s'amuse quoi :siffle:

J'ai aussi 160 LED RGB pilotées individuellement sur 4 fils en SPI... de quoi illuminer une ville entière... en HO bien entendu, ou en N :siffle:
Avatar de l’utilisateur
Ramboman
Disert
 
Messages: 423
Inscrit le: Lun 23 Oct 2006, 18:13
Localisation: Waterloo, Belgique
Âge: 73
Echelle pratiquée: LGB

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 17:53 
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.

Image

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. :wink:

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. :ange:

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 :

Image

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. :geek:

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 :
// 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 (" ") ;
}


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. :coeur1:
// 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) ;
}


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 !

Christian
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 18:12 
C'est tout pour les LED (pour l'instant ...)

Dans ce forum, je suis partis de mon article publié dans Loco-Revue N°798 (janvier 2014) pour vous montrer qu'un même montage peut avoir plusieurs applications, et j'ai également publié d'autres montages possibles, en essayant à chaque fois de bien expliquer leurs fonctionnements.

Je reste bien sûr à votre disposition pour répondre à vos interrogations. J'espère que vous serez nombreux à copier ces montages et aussi à les améliorer. Vous avez à votre disposition l'ensemble de ce qu'on peut trouver sur un réseau de trains miniatures, en matière d'animation lumineuse :
- feux tricolores
- feux de travaux
- enseigne de commerçants
- fêtes foraines
- soudure à arc

En vous inspirant de ces montages, il vous sera facilement possible de reproduire d'autres animations lumineuses comme :
- gyrophare de police ou de pompiers
- incendie
- appartements s'allumant de façon aléatoire à la tombée de la nuit
- feux de passage à niveau
- et bien d'autres choses encore ...

A vous de jouer :gne: Mais je reste à votre disposition pour vous aider à développer des choses nouvelles auxquelles je n'aurais pas pensé ! :D

Lors de la parution de mon prochain article dans Loco-Revue, concernant Arduino, j'ouvrirai un nouveau forum consacré au thème de l'article, pour vous permettre de poser vos questions ou bien pour donner d'autres exemples de réalisation.

Quel en sera le sujet ? Patience ..... :coeur1:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Mer 15 Jan 2014, 22:53 
Bonjour à tous,

Je vous propose une version du feu tricolor.
Code: Tout sélectionner
// cablage de l'Arduino
#define VOIE_1_VERT    4
#define VOIE_1_ORANGE  5
#define VOIE_1_ROUGE   6
#define VOIE_2_VERT    7
#define VOIE_2_ORANGE  8
#define VOIE_2_ROUGE   9

// nombre de voies de circulation a controler
#define NOMBRE_DE_VOIES 2

// table des feux : correspondance voie / feu / cablage
const byte feux[NOMBRE_DE_VOIES][3] =
             {{VOIE_1_VERT, VOIE_1_ORANGE, VOIE_1_ROUGE},
              {VOIE_2_VERT, VOIE_2_ORANGE, VOIE_2_ROUGE}};

// table des temps d'activation des feux {VERT, ORANGE, ROUGE*}
//    * temps avant que la voie suivante passe au vert
const int temps[NOMBRE_DE_VOIES][3] = {{60000, 7000, 2000},
                                       {50000, 2500, 1000}};

// definition de l'extinction et de l'allumage
// sorties en pulldown : allumé lorsque la sortie est à 1
#define ALLUME(v, f)   digitalWrite(feux[v - 1][f], HIGH)
#define ETTEIND(v, f)  digitalWrite(feux[v - 1][f], LOW)

// ***** Les modifications sont à faire au dessus de cette ligne ******

// état des feux
enum {VERT, ORANGE, ROUGE};

// variables
byte voiePassante = NOMBRE_DE_VOIES;//voie actuelement controlée
byte feuActif = ROUGE;//feu actif sur la voie de circulation

void setup () {
  for (byte v = 1; v <= NOMBRE_DE_VOIES; v++) {
    for (byte f = VERT; f <= ROUGE; f++) {
      pinMode(feux[v - 1] [f]  , OUTPUT);
      if (f == feuActif) {
        ALLUME(v, f);
      } else {
        ETTEIND(v, f);
      }
    }
  }
}

void loop () {
  switch (feuActif) {
    case VERT :
      ETTEIND(voiePassante, VERT);
      ALLUME(voiePassante, ORANGE);
      feuActif = ORANGE;
      break;
     
    case ORANGE :
      ETTEIND(voiePassante, ORANGE);
      ALLUME(voiePassante, ROUGE);
      feuActif = ROUGE;
      break;
     
    case ROUGE :
      if (!(voiePassante --)) {// passer à la voie suivante
        voiePassante = NOMBRE_DE_VOIES;//si == 0
      }
      ETTEIND(voiePassante, ROUGE);
      ALLUME(voiePassante, VERT);
      feuActif = VERT;
      break;
  }

  delay(temps[voiePassante - 1][feuActif]);
}

Tout ce qui est lié au modèle réduit et au câblage de l'Arduino se trouve au début du programme (jusqu'à la ligne "les motif…"). Pour les adaptations, il n'est pas nécessaire de toucher à la boucle principale.
L'étape suivante serai de gérer un allumage et une extinction progressifs (PWM PFM) et d'envisager une autre méthode pour gérer la temporisation (interruptions).
Il sera alors possible d'intégrer plusieurs "machines" totalement désynchronisées, comme présenté plus haut dans ce fil.

N'ayant pas assez de LED et pas voulu défaire le montage actuelle sur ma plaque d'essai, je n'ai pas pu tester ce programme mais il est prévu pour fonctionner avec le premier montage présenté sur ce fil. Si cela intéresse quelqu'un …

22h, j'ai corriger une erreur d'appel des tables dans ALLUME, ETTEIND, for (v…) du setup et temporisation =… .
23h, j'ai encore vu plein d'erreurs dans le programme. Elles sont corrigées.
MS2 CC2 S-DEC-4-DC Rocrail
macsddau
Papotier
 
Messages: 114
Inscrit le: Jeu 17 Oct 2013, 22:46
Echelle pratiquée: N

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Jeu 16 Jan 2014, 14:33 
Bonjour macsddau,

Je viens d'essayer ta solution. Le programme a été compilé sans problème et occupe 1434 octets (celui de Loco-Revue en occupait 1300) ; c'est bon signe !

Je l'ai donc téléversé sur mon Arduino Uno et j'ai vu s'allumer le vert d'un feu et le rouge de l'autre ; c'est encore bon signe !

Hélas, après plus rien ne se passe, même au delà d'une minute (le temps que tu as choisi pour le rouge) .... :mort:

Comme tu as dit avoir corrigé très tard certaines erreurs, je pense que tu n'as pas dû encore mettre la dernière version de ton programme.

J'espère qu'il te sera possible de nous donner une version déboguée, car cela montrera bien aux lecteurs qu'on peut programmer de différentes façons. Dans l'article de LR 798, mon but était de démontrer qu'un premier programme peut s'écrire "comme on parle". L'utilisation de tableaux peut être une façon de programmer plus élégante (mais pour cela , il aurait fallu que je développe la notion de tableaux et mon "espace" était compté).

Donc, à bientôt ; je garde le montage pour essayer ton programme dès que tu le sors. :wink:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

Re: Article Arduino de LR 798 (janvier 2014)

Publié: Jeu 16 Jan 2014, 15:50 
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 :lol: )
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 ! :D

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 ... :coeur2:
Avatar de l’utilisateur
Arduino
Prolixe
 
Messages: 1688
Inscrit le: Mer 25 Sep 2013, 17:14

PrécédentSuivant

Retour vers Arduino

Qui est en ligne ?

Utilisateur(s) parcourant actuellement ce forum : Aucun utilisateur inscrit et 2 invité(s)