Block System Arduino

Sujet: Block System Arduino Lun 30 Nov 2020 - 19:01

Bonjour

Il y a quelques temps, je suis tombé sur cette vidéo: https://www.youtube.com/watch?v=Yg6mkOfl6I8&t=1381s
Elle résume assez simplement la construction d'un block system a l'aide d'un Arduino et de capteurs infrarouge. J'ai donc reproduit ce système qui fonctionne a merveille Very Happy

Ma question est la suivante, y a t il la possibilité d'ajouter un autre signal et les faire fonctionner de manière indépendante l'un de l'autre. En effet, il reste sur l'Arduino suffisamment d'entrées analogiques et numériques pour y ajouter un autre signal. Cependant, je bloque sur le code!

J'ai réaffecter chacune des sorties et entrées mais je ne parviens pas a avoir mes deux signaux simultanement et indépendants...
Quelqu'un parmi vous aurait il suffisamment expérience pour m'indiquer comment m'y prendre?

Bien a tous!

Sujet: Re: Block System Arduino Lun 30 Nov 2020 - 20:09

[/url]

Salut,

J'apprécie de voir de plus en plus de modélistes se tourner vers l'arduino qui permet plein de choses.
Cependant, ne connaissant pas ton projet, il faudrait au moins que tu mettes le code pour qu'un arduiniste puisse te répondre utilement.
Mais de plus je te signale qu'il y a un site spécialisé dans l'arduino pour le train, c'est le suivant:
www.locoduino.org
Ils ont un forum sur lequel tu pourras poser ta question avec bien plus de chances d'avoir ta réponse.

Bonne journée
A+
Yves

Je suis d'accord avec SUPERN concernant le forum de Locoduino.

Tu peux malgré tout résoudre ton problème en utilisant un ATtiny85 en lieu et place d'un Uno.
Le principe : pour un block signal , un ATiny85.
Donc tes problèmes sont résolus...
les modifications du programme sont mineures pour l'adapter à cette petite puce.(Suppression de quelques lignes et modification des numéros de pins)

A toi de voir.

Bonne continuation

Bonjour

Pour répondre a SuperN, je n'ai pas fini d'explorer tout le site LocoDuino, qui est bien fourni Very Happy

Pour ce qui est du code, il est trouvable en description de la vidéo, mais je le détaillerai prochainement.

Fantasio, je ne connais pas cette puce, je vais me renseigner, cela vaut très certainement le coup.
J'ai opté pour l'option des détecteurs infrarouges car j'ai des gros doutes sur la possibilité de mettre en place des ILS sur un réseau en Z comme c'est détaillé sur le site locoduino.

Voici le code pour la mise en place d'un signal:
int sensePin1=A0;
int sensePin2=A1;
int RED=7;
int YELLOW=6;
int GREEN=5;
int POWER=8;

void setup() {
Serial.begin(9600);
pinMode(RED,OUTPUT);
pinMode(YELLOW,OUTPUT);
pinMode(GREEN,OUTPUT);
pinMode(POWER,OUTPUT);

}
enum SIGNALSTATES
{
ST_GREEN,
ST_RED1,
ST_RED2,
ST_YELLOW,
};
SIGNALSTATES signalState=ST_GREEN;

void loop() {
int valA1=analogRead(sensePin1);
int valA2=analogRead(sensePin2);
Serial.println(valA1);
Serial.println(valA2);
delay(200);

switch(signalState)
{
case ST_GREEN:
signalgreen(valA1, valA2);
break;
case ST_RED1:
signalred1(valA1, valA2);
break;
case ST_RED2:
signalred2(valA1, valA2);
break;
case ST_YELLOW:
signalyellow(valA1, valA2);
break;
}
}

void signalgreen(int valA1, int valA2){
digitalWrite(GREEN,LOW);
digitalWrite(RED,HIGH);
digitalWrite(YELLOW,HIGH);
digitalWrite(POWER,HIGH);

if (valA1<500 && valA2>500){
signalState=ST_RED1;
}
else if (valA1>500 && valA2<500){
signalState=ST_RED2;
}
}

void signalred1(int valA1, int valA2){
digitalWrite(GREEN,HIGH);
digitalWrite(RED,LOW);
digitalWrite(YELLOW,HIGH);
digitalWrite(POWER,HIGH);

if (valA1>500 && valA2<500){
signalState=ST_YELLOW;
}
}

void signalred2(int valA1, int valA2){
digitalWrite(GREEN,HIGH);
digitalWrite(RED,LOW);
digitalWrite(YELLOW,HIGH);
digitalWrite(POWER,HIGH);

if (valA1<500 && valA2>500){
signalState=ST_YELLOW;
}

}

void signalyellow(int valA1, int valA2){
digitalWrite(GREEN,HIGH);
digitalWrite(RED,HIGH);
digitalWrite(YELLOW,LOW);
digitalWrite(POWER,HIGH);
delay(5000);

if (valA1>500 && valA2>500){
signalState=ST_GREEN;
}
}

J'utilise les mêmes détecteurs IR que ceux de la vidéo.
Voici le programme modifié pour l'ATtiny85. je l'ai compilé , aucun problème.
/*
* Brochage Attiny85
*
* =|1 U 8|= VCC
* sensePin2 =|2 7|= GREEN
* sensePin1 =|3 6|= YELLOW
* GND =|4 5|= RED
*
*/

const byte sensePin1=A2; // patte 3 de l'attiny
const byte sensePin2=A3; // patte 2 de l'attiny
const byte RED=0; // patte 5 de l'attiny
const byte YELLOW=1; // patte 6 de l'attiny
const byte GREEN=2; // patte 7 de l'attiny

void setup() {
pinMode(RED,OUTPUT);
pinMode(YELLOW,OUTPUT);
pinMode(GREEN,OUTPUT);
}
enum SIGNALSTATES
{
ST_GREEN,
ST_RED1,
ST_RED2,
ST_YELLOW,
};
SIGNALSTATES signalState=ST_GREEN;

void loop() {
int valA1=analogRead(sensePin1);
int valA2=analogRead(sensePin2);

switch(signalState)
{
case ST_GREEN:
signalgreen(valA1, valA2);
break;
case ST_RED1:
signalred1(valA1, valA2);
break;
case ST_RED2:
signalred2(valA1, valA2);
break;
case ST_YELLOW:
signalyellow(valA1, valA2);
break;
}
}

void signalgreen(int valA1, int valA2){
digitalWrite(GREEN,LOW);
digitalWrite(RED,HIGH);
digitalWrite(YELLOW,HIGH);

if (valA1<500 && valA2>500){
signalState=ST_RED1;
}
else if (valA1>500 && valA2<500){
signalState=ST_RED2;
}
}

void signalred1(int valA1, int valA2){
digitalWrite(GREEN,HIGH);
digitalWrite(RED,LOW);
digitalWrite(YELLOW,HIGH);

if (valA1>500 && valA2<500){
signalState=ST_YELLOW;
}
}

void signalred2(int valA1, int valA2){
digitalWrite(GREEN,HIGH);
digitalWrite(RED,LOW);
digitalWrite(YELLOW,HIGH);

if (valA1<500 && valA2>500){
signalState=ST_YELLOW;
}

}

void signalyellow(int valA1, int valA2){
digitalWrite(GREEN,HIGH);
digitalWrite(RED,HIGH);
digitalWrite(YELLOW,LOW);
delay(5000);

if (valA1>500 && valA2>500){
signalState=ST_GREEN;
}
}

J'ai supprimé POWER, les leds doivent être alimentées directement par un +5V. et tout ce qui concerne la communication avec le moniteur série.
Concernant la programmation des ATtiny regarde cet article sur Locoduino:
https://www.locoduino.org/spip.php?article189

Bonne continuation

Salut,

Ce que Fantasio te propose c'est plutot d'utiliser un petit Atiny pour chaque bloc (et donc chaque signal) plutôt que de tout mettre dans un seul UNO ce qui provoque du cablage très long dans le réseau (type toile d'araignée).

Tu peux ainsi dupliquer le montage à base d'Atiny autant de fois que tu le veux.

A+
Yves

C'est exactement ça!

Pour mes petits montages je teste toujours sur un Uno et j'adapte suivant mes besoins sur des ATtiny.
"Small is beautiful" Very Happy

Je me considère encore comme débutant.
En se donnant un peu de peine on progresse, ceci est valable dans tous les domaines.
Mais vraiment l'utilisation de l'Arduino pour notre hobby c'est génial!

Oui, il semblerait que l'usage d'un ATtiny soit plus pertinent que celui d'un Arduino par signal, et par conséquent bien moins cher a mettre en place!

Et tu n'auras plus de limitation sur le nombre de signaux (2, 3,5...)

je le répète: La seule contrainte c'est la programmation!
Mais comme j'y suis arrivé, tout le monde peut le faire!

Tiens nous au courant de tes avancées

Voilà une petite mise en place sur mon réseau en Z

Pas encore passé au AtTtiny85, mais j'ai quand meme posé mes signaux sur mon reseau en Z pour faire un essai avec une circulation.
https://www.youtube.com/watch?v=JsBHhow1bGo
Je suis plutôt satisfait Smile

Le problème que tu auras à solutionner c'est l'installation de ton capteur IR. Il faut le dissimuler dans ton décor mais il doit continuer à détecter...

Au fait, ton chat n'est pas pas à la bonne échelle Very Happy

Bonne continuation à toi

Oui, justement! Je suis en train de bricoler une sortie de tunnel pour cacher au mieux les capteurs.
Et mon chat n'est pas du tout évident à gérer, des qu'elle entend un train tourner elle se précipite pour au mieux le voir passer au pire filer des coups de pattes...

Bonjour

Je me permets de mettre un lien du forum Locoduino qui propose un remplacement des barrières infrarouges "visibles" par un système plus discret.

Personnellement, je n'en suis pas encore là, mais il me semble que j'emploierai ce dispositif plutôt que la barrière IR.

https://forum.locoduino.org/index.php?topic=1119.0

Le type détecteur qu'utilise thomaswf fonctionne en réflexion.
Au repos la sortie est au niveau HAUT
Au passage du train une partie du rayon IR est réféchi vers le capteur et sa sortie passe au niveau BAS

Pour une barrière IR, l'emetteur est dans l'axe du récepteur. en absence de train la sortie est au niveau BAS.
Au passage du train, le faisceau est coupé et la sortie passe au niveau HAUT

Le défaut de ce type de capteur est le diamètre des leds: 5mm. Pas terrible pour la discrétion en N et je parle pas du Z ...
Mais le fonctionnement du capteur est bon .
On peut remédier en utilisant un capteur TCRT5000 monté ou non sur une petite platine directement utilisable avec l'arduino. les leds font 3mm (Locoduino en parle également)

Pour moi la barrière IR est un très bon système de détection . Pour info regardez cette vidéo de Svete Massikker son astuce est intéressante:
https://www.youtube.com/watch?v=Zixbz4O1xgM&ab_channel=SteveMassikker

Bonne continuation

@thomaswf

J'ai cogité sur ton programme. scratch

Rajouter un second signal implique que les deux signaux soient pouvoir fonctionner indépendamment l'un de l'autre. Donc la temporisation de 5s ne doit pas être bloquante -ce qui est le cas actuellement avec l'utilisation de la fonction delay- car pendant qu'elle se déroule l'Arduino est figé et on risque de passer à côté d'une détection pour le second signal. Evil or Very Mad

Même si je reste convaincu que l'utilisation des Attiny est préférable, je te propose de tester ce nouveau programme sur ton Arduino en espérant qu'il te conviendra.

Il est largement perfectible en j'accepte toutes les critiques car je suis loin d'être un expert. Smile

Code:: /*Gestion de 2 feux indépendants
* utilisation de temporisations non bloquantes
* alimentation +5v commune aux 2 feux
*/
const byte sensePin1 = 3; // branchement signal du capteur 1
const byte sensePin2 = 4; // branchement signal du capteur 2
const byte sensePin3 = 5; // branchement signal du capteur 3
const byte sensePin4 = 6; // branchement signal du capteur 4
const byte rouge1 = 7; // led rouge du feu 1
const byte jaune1 = 8; // led jaune du feu 1
const byte vert1 = 9; // led verte du feu 1
const byte rouge2 = 10; // led rouge du feu 2
const byte jaune2 = 11; // led jaune du feu 2
const byte vert2 = 12; // led verte du feu 2

int TempsDepartMemo1; // variables utilisées dans la temporisation non bloquante
int TempsDepartMemo2;
unsigned long temps1;
unsigned long temps2;

void setup()
{
  Serial.begin(9600);
  pinMode(rouge1, OUTPUT); // toutes les broches pour les leds dont en sortie
  pinMode(jaune1, OUTPUT);
  pinMode(vert1, OUTPUT);
  pinMode(rouge2, OUTPUT);
  pinMode(jaune2, OUTPUT);
  pinMode(vert2, OUTPUT);
  pinMode(sensePin1, INPUT_PULLUP);
  pinMode(sensePin2, INPUT_PULLUP);
  pinMode(sensePin3, INPUT_PULLUP);
  pinMode(sensePin4, INPUT_PULLUP);
}
enum SIGNALSTATES1{ST_GREEN1, ST_RED11, ST_RED21, ST_YELLOW1};
SIGNALSTATES1 signalState1 = ST_GREEN1;

enum SIGNALSTATES2{ST_GREEN2, ST_RED12, ST_RED22, ST_YELLOW2};
SIGNALSTATES2 signalState2 = ST_GREEN2;

void loop()
{
  int valA1 = digitalRead(sensePin1);// lecture des sorties des capteurs
  int valA2 = digitalRead(sensePin2);
  int valA3 = digitalRead(sensePin3);
  int valA4 = digitalRead(sensePin4);
  Serial.println(valA1);
  Serial.println(valA2);
  Serial.println(valA3);
  Serial.println(valA4);
  delay(200);

  switch (signalState1)
  {
   case ST_GREEN1:
   signalgreen1(valA1, valA2);
   break;

   case ST_RED11:
   signalred11(valA1, valA2);
   break;

   case ST_RED21:
   signalred21(valA1, valA2);
   break;

   case ST_YELLOW1:
   int tempsDepartMemo1 = 0;
   signalyellow1(valA1, valA2, tempsDepartMemo1);
   break;
  }
}

void signalgreen1(int valA1, int valA2)
{
  digitalWrite(vert1, LOW);
  digitalWrite(rouge1, HIGH);
  digitalWrite(jaune1, HIGH);
  if (valA1 == 0 && valA2 == 1)
  {
   signalState1 = ST_RED11;
  }
  else if (valA1 == 1 && valA2 == 0)
  {
   signalState1 = ST_RED21;
  }
}

void signalred11(int valA1, int valA2)
{
  digitalWrite(vert1, HIGH);
  digitalWrite(rouge1, LOW);
  digitalWrite(jaune1, HIGH);
  if (valA1 == 1 && valA2 == 0)
  {
   signalState1 = ST_YELLOW1;
  }
}

void signalred21(int valA1, int valA2)
{
  digitalWrite(vert1, HIGH);
  digitalWrite(rouge1, LOW);
  digitalWrite(jaune1, HIGH);
  if (valA1 == 0 && valA2 == 1)
  {
   signalState1 = ST_YELLOW1;
  }
}

void signalyellow1(int valA1, int valA2, int tempsDepartMemo1)
{
  digitalWrite(vert1, HIGH);
  digitalWrite(rouge1, HIGH);
  digitalWrite(jaune1, LOW);
  if (tempsDepartMemo1 == 0)
  {
   temps1 = millis(); // mémorisation du temps de départ
   tempsDepartMemo1 = 1; // variable mise à 1 = le temps est mémorisé
  }
  if (tempsDepartMemo1 == 1) // test si l'action de la temporisation est lancée
  {
   unsigned long tempsEcoule1 = millis() - temps1 ; // calcul du temps écoulé en millisecondes
   if (tempsEcoule1 > 5000) // test si le temps écoulé dépasse 5s
   {
   if (valA1 == 0 && valA2 == 1)
   {
   signalState1 = ST_GREEN1;
   }
   tempsDepartMemo1 = 0;
   }
  }
}

void signalgreen2(int valA3, int valA4)
{
  digitalWrite(vert2, LOW);
  digitalWrite(rouge2, HIGH);
  digitalWrite(jaune2, HIGH);
  if (valA3 == 0 && valA4 == 1)
  {
   signalState2 = ST_RED12;
  }
  else if (valA3 == 1 && valA4 == 0)
  {
   signalState2 = ST_RED22;
  }
}

void signalred12(int valA3, int valA4)
{
  digitalWrite(vert2, HIGH);
  digitalWrite(rouge2, LOW);
  digitalWrite(jaune2, HIGH);

  if (valA3 == 1 && valA4 == 0)
  {
   signalState2 = ST_YELLOW2;
  }
}

void signalred22(int valA3, int valA4)
{
  digitalWrite(vert2, HIGH);
  digitalWrite(rouge2, LOW);
  digitalWrite(jaune2, HIGH);

  if (valA3 == 0 && valA4 == 1)
  {
   signalState2 = ST_YELLOW2;
  }
}

void signalyellow2(int valA3, int valA4, int tempsDepartMemo2)
{
  digitalWrite(vert2, HIGH);
  digitalWrite(rouge2, HIGH);
  digitalWrite(jaune2, LOW);
  if (tempsDepartMemo2 == 0)
  {
   temps2 = millis(); // mémorisation du temps de départ
   tempsDepartMemo2 = 1; // variable mise à 1 = le temps est mémorisé
  }
  if (tempsDepartMemo2 == 1) // test si l'action de la temporisation est lancée
  {
   unsigned long tempsEcoule2 = millis() - temps2 ; // calcul du temps écoulé en millisecondes
   if (tempsEcoule2 > 5000) // test si le temps écoulé dépasse 5s
   {
   if (valA3 == 0 && valA4 == 1)
   {
   signalState2 = ST_GREEN2;
   }
   tempsDepartMemo2 = 0;
   }
  }
}

Bonne continuation

Hello Fantasio!
J'ai televersé le code sur mon Arduino, et je n'ai qu'un seul signal qui fonctionne pour le moment. Il faut que je potasse encore un peu la programmation, je ne suis pas assez expérimenter pour déterminer la ou ca coince!
J'ai également commandé des ATtiny, je pense en effet qu'ils seront plus adaptés a ce que je souhaite faire Smile

Bonjour Thomaswf et Fantasio,

Organisé sous forme de machine d'états, ce programme est plutôt bien structuré.

La fonction loop ne traite que la variable signalState1, c'est donc normal qu'il n'y ait qu'un signal qui fonctionne. La variable signalState2 n'est jamais traitée et les fonctions signal*2 jamais appelées.

Pour traiter plus facilement plusieurs signaux, il faudrait envisager un tableau de structures. Chaque structure contiendrait les pins du signal et son état. Les fonctions signal* devraient alors parcourir le tableau et traiter chaque signal.

Le site Locoduino décrit comment utiliser les tableaux: https://www.locoduino.org/spip.php?article227.

Bonne réalisation et bon début de semaine.

SavignyExpress a écrit:: ...La fonction loop ne traite que la variable signalState1, c'est donc normal qu'il n'y ait qu'un signal qui fonctionne. La variable signalState2 n'est jamais traitée et les fonctions signal*2 jamais appelées...

Merci SavignyExpress pour ton aide précieuse Very Happy

L'erreur était évidente. Enorme faute d'inattention de ma part. Je viens de modifier le programme pour qu'effectivement il prenne en compte signalState2.

Code:: /*Gestion de 2 feux indépendants
* utilisation de temporisations non bloquantes
* alimentation +5v commune aux 2 feux
*/
const byte sensePin1 = 3; // branchement signal du capteur 1
const byte sensePin2 = 4; // branchement signal du capteur 2
const byte sensePin3 = 5; // branchement signal du capteur 3
const byte sensePin4 = 6; // branchement signal du capteur 4
const byte rouge1 = 7; // led rouge du feu 1
const byte jaune1 = 8; // led jaune du feu 1
const byte vert1 = 9; // led verte du feu 1
const byte rouge2 = 10; // led rouge du feu 2
const byte jaune2 = 11; // led jaune du feu 2
const byte vert2 = 12; // led verte du feu 2

int TempsDepartMemo1; // variables utilisées dans la temporisation non bloquante
int TempsDepartMemo2;
unsigned long temps1;
unsigned long temps2;

void setup()
{
  Serial.begin(9600);
  pinMode(rouge1, OUTPUT); //toutes les broches pour les leds dont en sortie
  pinMode(jaune1, OUTPUT);
  pinMode(vert1, OUTPUT);
  pinMode(rouge2, OUTPUT);
  pinMode(jaune2, OUTPUT);
  pinMode(vert2, OUTPUT);
  pinMode(sensePin1, INPUT_PULLUP);
  pinMode(sensePin2, INPUT_PULLUP);
  pinMode(sensePin3, INPUT_PULLUP);
  pinMode(sensePin4, INPUT_PULLUP);
}
enum SIGNALSTATES1{ST_GREEN1, ST_RED11, ST_RED21, ST_YELLOW1};
SIGNALSTATES1 signalState1 = ST_GREEN1;

enum SIGNALSTATES2{ST_GREEN2, ST_RED12, ST_RED22, ST_YELLOW2};
SIGNALSTATES2 signalState2 = ST_GREEN2;

void loop()
{
  int valA1 = digitalRead(sensePin1);// lecture des sorties des capteurs
  int valA2 = digitalRead(sensePin2);
  int valA3 = digitalRead(sensePin3);
  int valA4 = digitalRead(sensePin4);
  Serial.println(valA1);
  Serial.println(valA2);
  Serial.println(valA3);
  Serial.println(valA4);
  delay(200);

  switch (signalState1)
  {
   case ST_GREEN1:
   signalgreen1(valA1, valA2);
   break;

   case ST_RED11:
   signalred11(valA1, valA2);
   break;

   case ST_RED21:
   signalred21(valA1, valA2);
   break;

   case ST_YELLOW1:
   int tempsDepartMemo1 = 0;
   signalyellow1(valA1, valA2, tempsDepartMemo1);
   break;
  }

  switch (signalState2)
  {
   case ST_GREEN2:
   signalgreen2(valA3, valA4);
   break;

   case ST_RED12:
   signalred12(valA3, valA4);
   break;

   case ST_RED22:
   signalred22(valA3, valA4);
   break;

   case ST_YELLOW2:
   int tempsDepartMemo2 = 0;
   signalyellow1(valA3, valA4, tempsDepartMemo2);
   break;
  }
}
void signalgreen1(int valA1, int valA2)
{
  digitalWrite(vert1, LOW);
  digitalWrite(rouge1, HIGH);
  digitalWrite(jaune1, HIGH);
  if (valA1 == 0 && valA2 == 1)
  {
   signalState1 = ST_RED11;
  }
  else if (valA1 == 1 && valA2 == 0)
  {
   signalState1 = ST_RED21;
  }
}

void signalred11(int valA1, int valA2)
{
  digitalWrite(vert1, HIGH);
  digitalWrite(rouge1, LOW);
  digitalWrite(jaune1, HIGH);
  if (valA1 == 1 && valA2 == 0)
  {
   signalState1 = ST_YELLOW1;
  }
}

void signalred21(int valA1, int valA2)
{
  digitalWrite(vert1, HIGH);
  digitalWrite(rouge1, LOW);
  digitalWrite(jaune1, HIGH);
  if (valA1 == 0 && valA2 == 1)
  {
   signalState1 = ST_YELLOW1;
  }
}

void signalyellow1(int valA1, int valA2, int tempsDepartMemo1)
{
  digitalWrite(vert1, HIGH);
  digitalWrite(rouge1, HIGH);
  digitalWrite(jaune1, LOW);
  if (tempsDepartMemo1 == 0)
  {
   temps1 = millis(); // mémorisation du temps de départ
   tempsDepartMemo1 = 1; // variable mise à 1 = le temps est mémorisé
  }
  if (tempsDepartMemo1 == 1) // test si l'action de la temporisation est lancée
  {
   unsigned long tempsEcoule1 = millis() - temps1 ; // calcul du temps écoulé en millisecondes
   if (tempsEcoule1 > 5000) // test si le temps écoulé dépasse 5s
   {
   if (valA1 == 0 && valA2 == 1)
   {
   signalState1 = ST_GREEN1;
   }
   tempsDepartMemo1 = 0;
   }
  }
}

void signalgreen2(int valA3, int valA4)
{
  digitalWrite(vert2, LOW);
  digitalWrite(rouge2, HIGH);
  digitalWrite(jaune2, HIGH);
  if (valA3 == 0 && valA4 == 1)
  {
   signalState2 = ST_RED12;
  }
  else if (valA3 == 1 && valA4 == 0)
  {
   signalState2 = ST_RED22;
  }
}

void signalred12(int valA3, int valA4)
{
  digitalWrite(vert2, HIGH);
  digitalWrite(rouge2, LOW);
  digitalWrite(jaune2, HIGH);

  if (valA3 == 1 && valA4 == 0)
  {
   signalState2 = ST_YELLOW2;
  }
}

void signalred22(int valA3, int valA4)
{
  digitalWrite(vert2, HIGH);
  digitalWrite(rouge2, LOW);
  digitalWrite(jaune2, HIGH);

  if (valA3 == 0 && valA4 == 1)
  {
   signalState2 = ST_YELLOW2;
  }
}

void signalyellow2(int valA3, int valA4, int tempsDepartMemo2)
{
  digitalWrite(vert2, HIGH);
  digitalWrite(rouge2, HIGH);
  digitalWrite(jaune2, LOW);
  if (tempsDepartMemo2 == 0)
  {
   temps2 = millis(); // mémorisation du temps de départ
   tempsDepartMemo2 = 1; // variable mise à 1 = le temps est mémorisé
  }
  if (tempsDepartMemo2 == 1) // test si l'action de la temporisation est lancée
  {
   unsigned long tempsEcoule2 = millis() - temps2 ; // calcul du temps écoulé en millisecondes
   if (tempsEcoule2 > 5000) // test si le temps écoulé dépasse 5s
   {
   if (valA3 == 0 && valA4 == 1)
   {
   signalState2 = ST_GREEN2;
   }
   tempsDepartMemo2 = 0;
   }
  }
}

Je vais suivre ton conseil et étudier de plus près l'excellent article de Jean-Luc sur les structures :
https://www.locoduino.org/spip.php?article107
Comme je l'ai dit précédemment je me considère comme débutant mais je veux progresser. D'ailleurs grâce à thomaswf j'ai appris, enfin, à maitriser la fonction millis() Laughing

Comme beaucoup d'autres je suis convaincu que le modélisme ferroviaire associé à l'Arduino est un formidable terrain de jeu. Et le plus difficile c'est juste de faire le premier pas...

@thomaswf
Essaye cette nouvelle version et tiens nous au courant et désolé pour cet oubli stupide dans mon programme.

Bonjour Fantasio,

En combinant les structures et les tableaux, le programme sera plus simple. Il ne sera plus nécessaire de dupliquer les constantes définissant les états, ni les fonctions de changement d'état.

C'est dans les commentaires de l'article sur les structures de Locoduino que la déclaration d'un tableau de structures est décrit. L'étape d'après c'est d'utiliser les objets, mais ce n'est peut-être pas nécessaire pour ce projet.

Je reste à disposition pour d'autres questions dans la mesure de mes disponibilités.

Merci, et j'apprécie vraiment ta proposition d'aide. Very Happy

Je vais étudier les structures en m'appuyant sur les articles de Locoduino. A terme je reprendrai ce programme.

Bonne continuation à toi

Bonsoir a tous!

Aujourd'hui j'ai eu l'occasion de tester le programme de Fantasio sur ATtiny85, c'est vraiment bien!! Je pense mettre ce système sur tout mes signaux! Un vidéo arrive certainement ce soir. En revanche, je ne parviens toujours pas a faire fonctionner mes 2 signaux sur un seul Arduino, il faut que je me documente, car je m’aperçoit qu'il me reste beaucoup de choses a apprendre...

Quoiqu'il en soit, je tiens a vous remercier pour votre aide! Il y a vraiment de belles choses a faire en modélisme avec ce genre d'outils!!

» Retour sur un block en bois...
» Un block automatique pour mon réseau
» Block automatique et enclenchements SNCF
» Besoin d'aide sur block Arnold 7695 MSB+ABS
» Block manuel de voie unique SNCF