Discussion :

[Jay M]

Bien sûr (si j'ai compris ce que vous voulez faire) vous pourriez avoir dans un boitier séparé un ensemble de boutons représentant vos aiguillages connectés à un Arduino (TCO) et quand un des boutons est actionné, ça envoie la commande textuelle correspondante sur le port Série qui arrive dans la MEGA qui contrôle les aiguillages.

certains utilisent le Xpressnet pour le transport -> cf locoduino

[jpbbricole]

Bonjour Jacques

Mon idée ... (peut-être complètement aberrante !) :
pour mon tableau de commande optique, le fameux TCO, j'ai prévu d'utiliser une UNO R3 avec un programme du style "chenillard" ....

Non ce n'est pas aberrant comme idée, mais ça complique, pour ce genre de configuration, je transformerai l'Arduino, Uno en l'occurence, en Slave i2C, commandé depuis le Mega qui enverrai les ordres aux LED, mais la version Neopixel, c'est 3 fils depuis le Mega vers le TCO.

B... UNO R3 avec un programme du style "chenillard" qui m'informera sur les voies sélectionnées.

C'est exactement la partie du programme que je suin entrain de développer, mais pas avec un programme chenillard, mais avec des LED Neopixel, tu devrait t'y intéresser, ça change la vie, surtout le câblage, 1 fil(+alim) pour commander, je crois, plus de 100 LED avec énormément de couleurs. Pour ce qui est des boutons de commande, regardes aussi du côté des MCP23017, qui sont, aussi, en i2C.
Si j'ai le temps je vais faire ce pupitre avec MCP23017 et Neopixel et te ferais des photos.

Question de terminologie aiguillage, rails, quand on a la situation, pour exemple, B1_G B3_D, comment s'appelle le tronçon ainsi créé, un bloc, un tronçon, un secteur....? Merci par avance.

A+
Cordialement
jpbbricole

[Jay M]

Question de terminologie aiguillage, rails, quand on a la situation, pour exemple, B1_G B3_D, comment s'appelle le tronçon ainsi cré, un bloque, un tronçon, un secteur....?

Salut @JP,

c'est amusant car n'y connaissant rien (encore moins en français) sur les aiguillages je m'étais posé la même question et j'avais fait une petite recherche et j'étais tombé sur cet article


il ne semble pas y avoir de nom particulier pour le tronçon de voie entre deux aiguillages (en pratique toutes les voies sont sans doute entre deux aiguillages), juste des noms pour les parties proches de l'aiguillage et la notion de voie directe et voie déviée

Mais bon - j'ai peut être pas trouvé, c'est pour cela que dans mon code j'utilisais la notion de "cheminement" mais tronçon c'est bien (mieux que bloc ou secteur à mon avis), éventuellement "segment de voie" ?

Si Jacques est un pro du train il doit savoir !

[jpbbricole]

Salut Jean-Claude
Concernant les Neopixel, les modèles que j'utilise sont ceux-ci,

Salut @Jay

Si Jacques est un pro du train il doit savoir !

Je crois que c'est beaucoup mieux, surtout que ça ne répond pas à ma question qui parle de "tronçon ainsi créé"

A+
Cordialement
jpbbricole

[Jay M]

Je crois que c'est beaucoup mieux, surtout que ça ne répond pas à ma question qui parle de "tronçon ainsi créé"

Le français n'est pas ma langue maternelle donc vous avez raison.
L'objectif de mon post était de partager ce que j'avais trouvé et du fait que je n'ai rien vu lié à un tronçon/segment lors de ma recherche.

Jay.

[Jsiorat]

Salut Jean-Claude
Concernant les Neopixel, les modèles que j'utilise sont ceux-ci,


jpbbricole

J'ai Tableau de Commande Optique (le TCO !) qui est au format d'une feuille A4, j'utilise des LEDs vertes de 3mm de diamètre.
Les LEDs NEOPIXELS sont beaucoup plus grosse, 9,6 mm ! Pas de place suffisante ! (photo sur la 1ère page de cette discussion)
Effectivement, on aborde un aiguillage soit en pointe soit en talon ; talon = par voie directe ou déviée ; ! Souvenirs du temps ou je conduisais le métro à Paris.
La dénomination de tronçon est très différente.

[jpbbricole]

Bonjour Jacques

Les LEDs NEOPIXELS sont beaucoup plus grosse, 9,6 mm ! Pas de place suffisante !

La dénomination de tronçon est très différente.

Compris pour les LED.
Je vais utiliser tronçon dans mon programme.

Je vais devoir faire une pose dans ce développement, j'ai un programme Arduino pour de la CNC (Plateau diviseur) à terminer.

A+
Cordialement
jpbbricole

[Jsiorat]

Dans ce bout de code, je trouve que l’allumage et l'extinction des LEDs est un peu brutal.
Peut-on intervenir dans le code pour intervenir sur la valeur de l'éclairage, comme si on utilisait un rhéostat ?
Sachant qu'il y a 10 LEDs (pas moins mais pas plus !) et pas assez de broche en PWM.
Merci pour votre aide,
Jacques

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
/*  Objectif : un chenillard sur 10 LEDs
   Pamiers, le 02/10/2020 - 14h40
*/
 
int timer = 100 ;
int intPin0 ;
int intPin1 ;
int intPin2 ;
 
void setup() {
  for (intPin0 = 4; intPin0 <= 13; intPin0++) {
    pinMode(intPin0, OUTPUT) ;
  }
}
void loop() {
  for (intPin0 = 4; intPin0 <= 13; intPin0++) {
    digitalWrite(intPin0, HIGH) ;  // allumage LED n°1
    delay(timer) ;
    digitalWrite(intPin1, LOW) ;   // extinction LED n° 2
    delay(timer) ;
    intPin1 = intPin0 + 1 ;        // sélection LED n°2
    digitalWrite(intPin1, HIGH) ;  // allumage LED n°2
    delay(timer) ;
    intPin2 = intPin0 + 2 ;        // sélection LED n°3
    digitalWrite(intPin2, HIGH) ;  // allumage LED n°3
    digitalWrite(intPin0, LOW) ;   // extinction LED n°1
  }
}

[Jay M]

Peut-on intervenir dans le code pour intervenir sur la valeur de l'éclairage, comme si on utilisait un rhéostat ?

Pas simplement, il faudrait fabriquer un simili PWM par vous même. Par exemple vous utiliseriez un des timer de votre Arduino Mega qui ferait par exemple 100 interruptions par seconde et dans cette interruption vous allez voir toutes vos LEDs qui ne sont ni éteintes, ni à fond et vous décidez de basculer leur état en fonction du pourcentage de brillance souhaité.

C'est l'avantage des NEOPIXELS et autres APA102 que @JP vous recommandait, on peut choisir le couleur, la brillance et ça ne prend que 2 pins de commande pour l'ensemble des LEDs. bien sûr elles sont un peu plus grosses que des LEDs 3mm mais vous pouvez les planquer "sous le capot" et juste faire un petit trou de la taille voulue au dessus pour laisser passer la lumière.

[Jsiorat]

C'est l'avantage des NEOPIXELS et autres APA102 que @JP vous recommandait, on peut choisir le couleur, la brillance et ça ne prend que 2 pins de commande pour l'ensemble des LEDs. bien sûr elles sont un peu plus grosses que des LEDs 3mm mais vous pouvez les planquer "sous le capot" et juste faire un petit trou de la taille voulue au dessus pour laisser passer la lumière.

Merci pour cette solution, je vais y penser.

[jpbbricole]

Bonjour Jacques

C'est l'avantage des NEOPIXELS et autres APA102 que @JP vous recommandait, on peut choisir le couleur, la brillance...

Je plussoie @Jay M, pour "colorer" ces LED, on leur transmet 3 paramètres, R G B, sous la forme 0-255, 0-255, 0-255 qui définit la luminosité de chaque couleur, ça démontre l'immense possibilité de couleurs et, surtout, que chaque LED a son "PWM"
On peut, également remplacer ces 3 intensités par le code de la couleur selon ce tableau.

Les commandes ressemblent à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
	pixels.setPixelColor(12, 255, 0, 0);
	pixels.setPixelColor(12, 0, 120, 0);
	pixels.setPixelColor(12, 10, 120, 50);

Pour ce qui est des trous, le trou de 3mm est suffisant, il suffit de régler l'intensité des LED. Sache, que pour travailler, j'ai mis l'intensité à 5 sur 255 pour ne pas m'abîmer les yeux!

A+
Cordialement
jpbbricole

[Jay M]

Si vous voulez rester sur vos LEDs (avec risque de mettre un peu à genou votre MEGA) voici un bout de code qui va profiter de la persistance rétinienne pour vous montrer une LED plus ou moins brillante avec 10 valeurs de brillance (de 0 à 9).

Vous branchez
- une LED Verte sur la pin 2 (au travers d'une résistance de limitation de courant)
- une LED Rouge sur la pin 3 (au travers d'une résistance de limitation de courant)
- vous chargez le code ci dessous dans l'Arduino
- vous ouvrez la console série à 115200 bauds

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <TimerOne.h> // https://github.com/PaulStoffregen/TimerOne
 
const uint8_t greenPin = 2;
const uint8_t redPin = 3;
 
struct t_dimmableLed {
  const uint8_t ledPin;
  volatile uint8_t ledBrightness; // 0 OFF, 9 = full bright
};
 
t_dimmableLed ledArray[] = {
  {greenPin, 0},
  {redPin, 9},
};
const byte numberOfLeds = sizeof ledArray / sizeof ledArray[0];
 
void handleDimming(void)
{
  static uint8_t tickCount = 0;
  if (++tickCount > 9) tickCount = 0;
  for (uint8_t l = 0; l < numberOfLeds; l++) {
    uint8_t b = ledArray[l].ledBrightness;
    uint8_t p = ledArray[l].ledPin;
    if (b == 0) digitalWrite(p, LOW);
    else digitalWrite(p, tickCount < b);
  }
}
 
void setup()
{
  for (uint8_t l = 0; l < numberOfLeds; l++) pinMode(ledArray[l].ledPin, OUTPUT);
  Serial.begin(115200);
 
  Timer1.initialize(2000); // 500Hz
  Timer1.attachInterrupt(handleDimming);
  Timer1.start();
}
 
void loop()
{
  int v = Serial.read();
  if ((v >= '0') && (v <= '9')) {
    ledArray[0].ledBrightness = v - '0';
    ledArray[1].ledBrightness = 9 - (v - '0');
  } else if (v == 'A') { // allumage progressif
    for (int8_t b = 0; b < 10; b++) {
      ledArray[0].ledBrightness = b;
      ledArray[1].ledBrightness = b;
      delay(100);
    }
  } else if (v == 'E') { // extinction progressive
    for (int8_t b = 9; b >= 0; b--) {
      ledArray[0].ledBrightness = b;
      ledArray[1].ledBrightness = b;
      delay(100);
    }
  }
}

Vous devriez voir la LED rouge allumée à fond et la LED verte éteinte.
si vous tapez 'A' (majuscule) et validez vous devriez voir les deux LEDs s'Allumer à fond en 1 seconde environ
si vous tapez 'E' (majuscule) et validez vous devriez voir les deux LEDs s'Eteindre à fond en 1 seconde environ
si vous tapez un chiffre entre 0 (éteint) et 9 (à fond), la LED verte prend cette brillance et la LED rouge la brillance inverse. par exemple si vous tapez 1 la LED verte brille un peu et la rouge est presque à fond. si vous tapez 8 c'est l'inverse, si vous tapez 5 elles sont toutes les deux moyennement brillantes

Les Led à gérer sont décrites dans un tableau (ledArray) de structure de type t_dimmableLed. Une t_dimmableLed étant une structure avec le N° de pin et la valeur de la brillance entre 0 (éteinte) et 9 (à fond). Quand on veut changer la brillance, on modifie l'attribut ledBrightness d'une des entrées du tableau et ça sera pris en compte lors des prochaines interruptions.

J'utilise une interruption matérielle avec la bibliothèque TimerOne de Paul Stoffregen qui permet d'avoir simplement une interruption appelée tous les ∆t. Ici , pour arriver à avoir une persistence rétinienne correcte je demande une interruption toutes les ∆t =2000 µs (2ms) soit 500 fois par seconde!

Plus vous aurez de LEDs et plus l'interruption prendra du temps à exécuter (elle passe en revue toutes les LEDs) et ce 500 fois par secondes (en plus digitalWrite n'est pas rapide).. vous imaginez donc que ça met une pression assez forte sur votre arduino et il pourrait être moins réactif pour autre chose... C'est pour cela que ce n'est pas une solution super recommandable.

Si vous souhaitez conserver des LEDs en PWM matériel et en gérer vraiment bcp, vous pourriez regarder du côté du composant PCA9685. Adafruit en commercialise un sous forme de module prêt à l'emploi (il y a des copie en Asie) et ça vous permet d'avoir 16 PWM pilotables en I2C et on peut chaîner 62 de ces modules, théoriquement vous pourriez piloter 992 LEDs....


PS: pour ceux qui sont un peu avancés et se posent la question, je n'ai pas mis de section critique lors de la modification de brightness car la valeur tient sur 1 octet donc l'afectation mémoire est atomique.

[Jsiorat]

Je suis impressionné par vos connaissances.

Vous me donnez beaucoup de travail mais quel bon boulot ! je vais encore passer des heures à étudier tout ça, ma compagne va me faire la gueule parce que je vais passer mon libre (normalement au jardin ou à mon atelier !) devant l'ordinateur !

Encore un grand merci !
Très cordialement, Jacques

[jpbbricole]

Bonsoir Jacques

Tout simple pour le PWM sur toutes les PIN, y compris les A0 et suivantes, la bibliothèque SoftPWM.

PS: N'oublies quand même pas le jardin!

Bonne soirée
Cordialement
jpbbricole

[Jay M]

Oui - effectivement vous pouvez passer par une bibliothèque qui cache la mécanique. Elle fonctionne sur le même principe mais au lieu d’utiliser Timer 1 ils ont pris Timer 2.

Faut savoir alors ce qu’il se passe en dessous suivant les besoins du système:

- ils ont une interface conceptuelle de haut niveau avec une classe qui simplifie le développement (dans mon code c’est vous qui gérez à la main)
- Ils ont 100 niveaux de luminosité (Le code ci dessous n’en traite que 10)
- Ils gèrent 20 pins au Max (modifiable dans le code de la bibliothèque mais ça mange plus de mémoire même si vous n’utilisez pas les pins).
- comme ils prennent une fréquence d’interruption à 15.6kHz vous vous retrouvez à passer 20 à 30% du temps CPU dans leur interruption (Le code ci dessous n’est qu’à 500Hz donc 31 fois moins de pression sur le CPU)

[Jsiorat]

Bonsoir Jacques

Tout simple pour le PWM sur toutes les PIN, y compris les A0 et suivantes, la bibliothèque SoftPWM.

jpbbricole

Bonjour ( et pourtant ... pas bon jour ! la pluie donc pas de jardin, et le code ci-dessus !)

J'ai repris mon chenillard et l'ai modifié pour utilisé la bibliothèque SoftPWM.h
Voilà mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/* JSiorat
   Objectif : un chenillard sur 10 LEDs avec extinction douce ??
   Pamiers, le 02/10/2020 - 14h40
*/
 
#include <SoftPWM.h>
 
//int timerA = 100 ;
int intPin0 ;
int intPin1 ;
//int intPin2 ;
 
void setup() {
  SoftPWMBegin() ;
  for (intPin0 = 4; intPin0 <= 13; intPin0++) {
    // pinMode(SoftPWM(intPin0), OUTPUT) ;
    SoftPWMSet(intPin0, 0) ;    
  }
  SoftPWMSetFadeTime(intPin0, 1000, 1000) ;
 
}
void loop() {
  for (intPin0 = 4; intPin0 <= 13; intPin0++) {
    //digitalWrite(intPin0, HIGH) ;  // allumage LED n°1
    //delay(timerA) ;
    //digitalWrite(intPin1, LOW) ;   // extinction LED n° 2
    //delay(timerA) ;
    //intPin1 = intPin0 + 1 ;        // sélection LED n°2
    //digitalWrite(intPin1, HIGH) ;  // allumage LED n°2
    //delay(timerA) ;
    //intPin2 = intPin0 + 2 ;        // sélection LED n°3
    //digitalWrite(intPin2, HIGH) ;  // allumage LED n°3
    //digitalWrite(intPin0, LOW) ;   // extinction LED n°1
    SoftPWMSet(intPin0, 255) ;
    delay(500) ;
    intPin1 = intPin0 + 1 ;
    SoftPWMSet(intPin0, 0) ;
    delay(250) ;
    SoftPWMSet(intPin1, 255) ;
    delay(500) ;
    SoftPWMSet(intPin1, 0) ;
    delay(250) ;    
  }
}

Le souci il est que les LEDs s'allument 2 fois coup sur coup avant de passer à la suivante et avec une extinction non pas en douceur mais brutale !
Je sais, je sais ... suis pas programmeur ! mais l'erreur elle est ou ?

Code modifié est basé sur cet original :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <SoftPWM.h>
 
void setup()
{
  SoftPWMBegin();
 
  SoftPWMSet(13, 0);
 
  SoftPWMSetFadeTime(13, 1000, 1000);
}
 
void loop()
{
  SoftPWMSet(13, 255);
  delay(500);
  SoftPWMSet(13, 0);
  delay(500);
}

Merci, de bien vouloir me dire cette erreur ...
Jacques

[jpbbricole]

Bonjour Jacques

J'ai repris et légèrement modifié l'exemple de la bibliothèque SoftPWM.h, SoftPWM_LEDHead_Bounce

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <SoftPWM.h>
 
#define DELAY 100
uint8_t leds[4] = {22, 23, 24,25};
const int ledsNbr = sizeof(leds);
 
void setup()
{
  Serial.begin(115200);
  SoftPWMBegin();
 
  for (int i = 0; i < 8; i++)
  {
    SoftPWMSet(leds[i], 0);
  }
 
  SoftPWMSetFadeTime(ALL, 50, 400);
}
 
void loop()
{
  for (int i = 0; i < ledsNbr; i++)
  {
    SoftPWMSet(leds[i+1], 255);
    SoftPWMSet(leds[i], 0);
    delay(DELAY);
  }
 
  delay(400);
 
  for (int i = ledsNbr-1; i > 0; i--)
  {
    SoftPWMSet(leds[i-1], 255);
    SoftPWMSet(leds[i], 0);
    delay(DELAY);
  }
 
  delay(400);
}

C'est pas parfait, mais un bon début. Il faut jouer avec SoftPWMSetFadeTime(ALL, 50, 400); et les delays.

PS:Navré pour le jardin

Cordialement
jpbbricole

[Jsiorat]

Salut JP

Je le garde tel que ! il est exactement comme je le voulais sur 10 LEDs !
Je vais m'amuser à modifier les delay et la puissance histoire d'en apprendre un peu plus encore.
Merci, merci (je ne le chanterai pas, mais la reconnaissance est là !)

[jpbbricole]

Salut Jacques

Super, mais n'oublies pas le jardin

Bonne soirée
jpbbricole

[kaitlyn]

Bonjour,

Sur un Mega, si je me souviens bien, il y a au moins une douzaine de broches pseudo-analogiques (analogWrite()/PWM).
Qu'est-ce qu'il y a actuellement dessus (ou prévu) qui ne puisse pas être placé ailleurs au profit de ces "10 LEDs" ?