Passage a niveau a 4 barrieres

Bonjour
j essai de crée un passage a niveau avec 4 barrières pour mon réseau ferroviaire en ho avec une détection des train par des capteur anticollision .j ai trouve sur le net quelque conception mais seulement 2 barrières une Bonne basse me direz vous mais je n arrive pas a mettre ne place le décalage entre les barrières 1/3 et 2/4
j essais de mettre ce que j aimerais obtenir et ce que j ai déjà mis en place je mets en pièce joint le document word espérant être clair dans mes explication merci pour votre aide et vos explications

Et voici le code que j essais de modifier pour pouvoir avoir un décalage entre les deux servo moteur ( pour l instant car une fois le programme OK je ferais deux fois deux servo en parallèle )

// C++ code
//
#include <Servo.h>
// Déclaration de constantes et variables
const int Detect1 = A0; // Détection 1 branchée sur l'entée A0
const int Detect2 = A1; // Détection 2 branchée sur l'entée A1
const int feu_droit = 13; // Première paire de feux
const int feu_gauche = 12; // Deuxième paire de feux
const int pulse_dfplayer = 11;
const int barriere1 = 8; // Fil signal servo1
const int barriere2 = 9; // Fil signal Servo2
int tempo_fermeture = 4000; // temps clignotement avant fermeture barrières
int tempo_led = 500; // tempo cligno
int angle_fermeture = 0; // angle servo position fermée
int angle_ouverture = 80; // angle servo position ouverte
int vitesse_barriere = 70; // temps entre 2 degrés
int inhibition = 10000; // Pendant cette durée le PN ne peut pas se redéclencher
int angle_barriere;
Servo servo1;
Servo servo2;
unsigned long compteur_temps;
boolean etat_feux = false; // Variable 0 si leds éteintes et 1 si allumées
int valeur_Detect1 = 1023; // Détecteur 1 ( + de 512 pas de détection. - de 512 détection.)
int valeur_Detect2 = 1023; // Détecteur 2
int premiere_detection = 0; // 1 si détecteur1 en premier, 2 si détecteur2 en premier.
boolean detection = false; // 0 si pas de détection. 1 si train détecté.
boolean barriere_ouverte; // 1 si barrières ouvertes.

void setup() {

pinMode(feu_droit,OUTPUT);
pinMode(feu_gauche,OUTPUT);
pinMode(pulse_dfplayer,OUTPUT);
digitalWrite(pulse_dfplayer,HIGH);

servo1.attach(barriere1,500,2500);
servo2.attach(barriere2,500,2500);
servo1.write(angle_ouverture); //ouverture au début
servo2.write(angle_ouverture);
barriere_ouverte = true;
}

void loop()
{
valeur_Detect1 = analogRead(Detect1);
valeur_Detect2 = analogRead(Detect2);
if (detection == 1 && premiere_detection == 0) {
if (valeur_Detect1 > 512 && valeur_Detect2 > 512) {
digitalWrite(feu_droit,LOW);
digitalWrite(feu_gauche,LOW);
for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES

servo1.write(angle_barriere);

servo2.write(angle_barriere);
delay(vitesse_barriere);
}
barriere_ouverte = true;

detection = 0;
//digitalWrite(feu_droit,LOW);
//digitalWrite(feu_gauche,LOW);
delay(inhibition);
}
}
// Permet de savoir quel détecteur est passé à l'état bas en premier
if (detection == false) {
// détection d'un train
if (valeur_Detect1 < 512 || valeur_Detect2 < 512) {
detection = true;
digitalWrite(pulse_dfplayer,LOW);
delay(100);
digitalWrite(pulse_dfplayer,HIGH);
// Mise en mémoire du détecteur.
if (valeur_Detect1 < 512) {
premiere_detection = 1;
} else {
premiere_detection = 2;
}
}
}
// Un train est détecté.
else {

Fonction_feux(); // Appel de la fonction qui gère les feux

if (barriere_ouverte == true) {
for (int tempo = 0; tempo <= tempo_fermeture; tempo +=1){ // Temporisation avant fermeture
Fonction_feux(); // Appel de la fonction qui gère les feux
delay(1);
}

for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES

servo1.write(angle_barriere);
servo2.write(angle_barriere);

Fonction_feux(); // Appel de la fonction qui gère les feux
delay(vitesse_barriere); // Vitesse angle barrière
}
barriere_ouverte = false;

}
if (premiere_detection == 1) {
if (valeur_Detect2 < 512) {
premiere_detection = 0;;
}
}
if (premiere_detection == 2) { // Si non c'est que c'est le 2eme capteur
if (valeur_Detect1 < 512) {
premiere_detection = 0;
}
}
}
delay(50);
}
void Fonction_feux() {
if (millis() > compteur_temps + tempo_led) {
compteur_temps = millis();
if (etat_feux == false) {
etat_feux = true;
digitalWrite(feu_droit,HIGH);
digitalWrite(feu_gauche,HIGH);

} else {
etat_feux = false;
digitalWrite(feu_droit,LOW);
digitalWrite(feu_gauche,LOW);
}
}
}

Bonjour @hinano80

Ton code aura davantage de lecteurs s'il est formaté conformément aux recommandations des Bonnes pratiques du Forum Francophonre (indentation et utlisisation des balises appropriées)

Pièce jointe Word ? pas l'idéal pour les nombreux utilisateurs de smartpnones, là encore tu perd des aides potentielles

Bonsoir hinano80

Pour voire si j'ai bien compris, que ce soit le détecteur 1 (D1) ou le 2 (D2) en premier, c'est de toute façon les barrières 1/3 puis, 10 secondes après ce sont les 2/4 qui se baissent?

Cordialement
jpbbricole

bonjour et merci de prendre un peu de temps pour mon problème
oui c est bien cela quand un détecteur détecte un train il déclenche le signal sonore et les feu 10s les barrières 1/3 baissent délais de 10s et les barrières 2/4 baissent a leurs tour

Bonjour hinano80

Ah! le train électrique, c'est magique :wink:
Je pense avoir compris ton problème :wink:

Voilà ma réflection, j'ai dédoublé tes servos:

const int barriere1 = 8; // Fil signal servo1
const int barriere2 = 9; // Fil signal Servo2
const int barriere3 = 8; // Fil signal servo1
const int barriere4 = 9; // Fil signal Servo2

......

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;

ainsi que les opérations nécessaires à ces nouveaux servo.
tu dois décider des pin pour barriere3 et barriere4 (actuellement celles de 1 et 2 !!!)

Ensuite, j'ai séparé les opération ouverture/fermeture 1-3 et 2-4 de façon a pouvoir y insérer une temporisation.
En exemple, ouverture:

		for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
			servo1.write(angle_barriere);
			servo3.write(angle_barriere);
			delay(vitesse_barriere);
		}
		
		// Temporisation entre les groupes 1-3 et 2-4
		for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
			Fonction_feux(); // Appel de la fonction qui gère les feux
			delay(1);
		}
		
		for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
			servo2.write(angle_barriere);
			servo4.write(angle_barriere);
			delay(vitesse_barriere);
		}

Et le code complet:

// C++ code
//
#include <Servo.h>
// Déclaration de constantes et variables
const int Detect1 = A0; // Détection 1 branchée sur l'entée A0
const int Detect2 = A1; // Détection 2 branchée sur l'entée A1
const int feu_droit = 13; // Première paire de feux
const int feu_gauche = 12; // Deuxième paire de feux
const int pulse_dfplayer = 11;
const int barriere1 = 8; // Fil signal servo1
const int barriere2 = 9; // Fil signal Servo2
const int barriere3 = 8; // Fil signal servo1
const int barriere4 = 9; // Fil signal Servo2
int tempo_fermeture = 4000; // temps clignotement avant fermeture barrières
int tempo_barrieres_13_24 = 10000; // temps entre les barrières 1-3 et 2-4
int tempo_led = 500; // tempo cligno
int angle_fermeture = 0; // angle servo position fermée
int angle_ouverture = 80; // angle servo position ouverte
int vitesse_barriere = 70; // temps entre 2 degrés
int inhibition = 10000; // Pendant cette durée le PN ne peut pas se redéclencher
int angle_barriere;
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
unsigned long compteur_temps;
boolean etat_feux = false; // Variable 0 si leds éteintes et 1 si allumées
int valeur_Detect1 = 1023; // Détecteur 1 ( + de 512 pas de détection. - de 512 détection.)
int valeur_Detect2 = 1023; // Détecteur 2
int premiere_detection = 0; // 1 si détecteur1 en premier, 2 si détecteur2 en premier.
boolean detection = false; // 0 si pas de détection. 1 si train détecté.
boolean barriere_ouverte; // 1 si barrières ouvertes.

void setup() {

	pinMode(feu_droit,OUTPUT);
	pinMode(feu_gauche,OUTPUT);
	pinMode(pulse_dfplayer,OUTPUT);
	digitalWrite(pulse_dfplayer,HIGH);

	servo1.attach(barriere1,500,2500);
	servo2.attach(barriere2,500,2500);
	servo1.write(angle_ouverture); //ouverture au début
	servo2.write(angle_ouverture);
	servo3.attach(barriere3,500,2500);
	servo4.attach(barriere4,500,2500);
	servo3.write(angle_ouverture); //ouverture au début
	servo4.write(angle_ouverture);
	barriere_ouverte = true;
}

void loop()
{
	valeur_Detect1 = analogRead(Detect1);
	valeur_Detect2 = analogRead(Detect2);
	if (detection == 1 && premiere_detection == 0) {
		if (valeur_Detect1 > 512 && valeur_Detect2 > 512) {
			digitalWrite(feu_droit,LOW);
			digitalWrite(feu_gauche,LOW);
			
			for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
				servo1.write(angle_barriere);
				servo3.write(angle_barriere);
				delay(vitesse_barriere);
			}
			
			// Temporisation entre les groupes 1-3 et 2-4
			for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			
			for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
				servo2.write(angle_barriere);
				servo4.write(angle_barriere);
				delay(vitesse_barriere);
			}
			
			barriere_ouverte = true;

			detection = 0;
			//digitalWrite(feu_droit,LOW);
			//digitalWrite(feu_gauche,LOW);
			delay(inhibition);
		}
	}
	// Permet de savoir quel détecteur est passé à l'état bas en premier
	if (detection == false) {
		// détection d'un train
		if (valeur_Detect1 < 512 || valeur_Detect2 < 512) {
			detection = true;
			digitalWrite(pulse_dfplayer,LOW);
			delay(100);
			digitalWrite(pulse_dfplayer,HIGH);
			// Mise en mémoire du détecteur.
			if (valeur_Detect1 < 512) {
				premiere_detection = 1;
				} else {
				premiere_detection = 2;
			}
		}
	}
	// Un train est détecté.
	else {

		Fonction_feux(); // Appel de la fonction qui gère les feux

		if (barriere_ouverte == true) {
			for (int tempo = 0; tempo <= tempo_fermeture; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			// Premier groupe servo 1 et 3
			for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES

				servo1.write(angle_barriere);
				servo3.write(angle_barriere);

				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(vitesse_barriere); // Vitesse angle barrière
			}
			
			// Temporisation entre les groupes 1-3 et 2-4
			for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			
			// Deuxième groupe servo 2 et 4
			for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES

				servo2.write(angle_barriere);
				servo4.write(angle_barriere);

				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(vitesse_barriere); // Vitesse angle barrière
			}
			barriere_ouverte = false;

		}
		if (premiere_detection == 1) {
			if (valeur_Detect2 < 512) {
				premiere_detection = 0;;
			}
		}
		if (premiere_detection == 2) { // Si non c'est que c'est le 2eme capteur
			if (valeur_Detect1 < 512) {
				premiere_detection = 0;
			}
		}
	}
	delay(50);
}
void Fonction_feux() {
	if (millis() > compteur_temps + tempo_led) {
		compteur_temps = millis();
		if (etat_feux == false) {
			etat_feux = true;
			digitalWrite(feu_droit,HIGH);
			digitalWrite(feu_gauche,HIGH);

			} else {
			etat_feux = false;
			digitalWrite(feu_droit,LOW);
			digitalWrite(feu_gauche,LOW);
		}
	}
}

Ce code compile sans problème mais n'est pas testé en vrai, mon train électrique est à la cave :cry:
Je te laisse jouer au jeux des 7 (voire plus) différences et poser les bonnes question :wink:

Cordialement
jpbbricole

mille merci je vais teste

je viens de teste sur tinkercad c est exactement ce que voulais super mille merci ça marche :smile:

Bonsoir hinano80

Super!
Bonne continuation!

Cordialement
jpbbricole

bonjour après avoir rapidement teste le programme avec tinkercad je trouvais ça super mais je me suis aperçu en faisant les essais sur breadboard que lors de la remonte des barrières il y avait un délais entre 1/3 et 2/4 comme pour la fermeture j ai essaye de le supprime mais n y arrive pas ; je me suis dit que soit je réduisais le délais entre les fermeture ou je je supprimais ce délais lors de l ouverture mais comme je suis pas très doué je ne trouve pas la solution merci de votre aide

Essaies ça, j'ai simplement regroupé la fermeture des 4 servo dans la même boucle et désactivé le reste.

// C++ code
//
#include <Servo.h>
// Déclaration de constantes et variables
const int Detect1 = A0; // Détection 1 branchée sur l'entée A0
const int Detect2 = A1; // Détection 2 branchée sur l'entée A1
const int feu_droit = 13; // Première paire de feux
const int feu_gauche = 12; // Deuxième paire de feux
const int pulse_dfplayer = 11;
const int barriere1 = 8; // Fil signal servo1
const int barriere2 = 9; // Fil signal Servo2
const int barriere3 = 8; // Fil signal servo1
const int barriere4 = 9; // Fil signal Servo2
int tempo_fermeture = 4000; // temps clignotement avant fermeture barrières
int tempo_barrieres_13_24 = 10000; // temps entre les barrières 1-3 et 2-4
int tempo_led = 500; // tempo cligno
int angle_fermeture = 0; // angle servo position fermée
int angle_ouverture = 80; // angle servo position ouverte
int vitesse_barriere = 70; // temps entre 2 degrés
int inhibition = 10000; // Pendant cette durée le PN ne peut pas se redéclencher
int angle_barriere;
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
unsigned long compteur_temps;
boolean etat_feux = false; // Variable 0 si leds éteintes et 1 si allumées
int valeur_Detect1 = 1023; // Détecteur 1 ( + de 512 pas de détection. - de 512 détection.)
int valeur_Detect2 = 1023; // Détecteur 2
int premiere_detection = 0; // 1 si détecteur1 en premier, 2 si détecteur2 en premier.
boolean detection = false; // 0 si pas de détection. 1 si train détecté.
boolean barriere_ouverte; // 1 si barrières ouvertes.

void setup() {

	pinMode(feu_droit,OUTPUT);
	pinMode(feu_gauche,OUTPUT);
	pinMode(pulse_dfplayer,OUTPUT);
	digitalWrite(pulse_dfplayer,HIGH);

	servo1.attach(barriere1,500,2500);
	servo2.attach(barriere2,500,2500);
	servo1.write(angle_ouverture); //ouverture au début
	servo2.write(angle_ouverture);
	servo3.attach(barriere3,500,2500);
	servo4.attach(barriere4,500,2500);
	servo3.write(angle_ouverture); //ouverture au début
	servo4.write(angle_ouverture);
	barriere_ouverte = true;
}

void loop()
{
	valeur_Detect1 = analogRead(Detect1);
	valeur_Detect2 = analogRead(Detect2);
	if (detection == 1 && premiere_detection == 0) {
		if (valeur_Detect1 > 512 && valeur_Detect2 > 512) {
			digitalWrite(feu_droit,LOW);
			digitalWrite(feu_gauche,LOW);
			
			for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
				servo1.write(angle_barriere);
				servo3.write(angle_barriere);
				delay(vitesse_barriere);
			}
			
			// Temporisation entre les groupes 1-3 et 2-4
			for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			
			for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
				servo2.write(angle_barriere);
				servo4.write(angle_barriere);
				delay(vitesse_barriere);
			}
			
			barriere_ouverte = true;

			detection = 0;
			//digitalWrite(feu_droit,LOW);
			//digitalWrite(feu_gauche,LOW);
			delay(inhibition);
		}
	}
	// Permet de savoir quel détecteur est passé à l'état bas en premier
	if (detection == false) {
		// détection d'un train
		if (valeur_Detect1 < 512 || valeur_Detect2 < 512) {
			detection = true;
			digitalWrite(pulse_dfplayer,LOW);
			delay(100);
			digitalWrite(pulse_dfplayer,HIGH);
			// Mise en mémoire du détecteur.
			if (valeur_Detect1 < 512) {
				premiere_detection = 1;
				} else {
				premiere_detection = 2;
			}
		}
	}
	// Un train est détecté.
	else {

		Fonction_feux(); // Appel de la fonction qui gère les feux

		if (barriere_ouverte == true) {
			for (int tempo = 0; tempo <= tempo_fermeture; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			// Premier groupe servo 1, 2, 3, 4
			for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES

				servo1.write(angle_barriere);
				servo3.write(angle_barriere);
				servo2.write(angle_barriere);
				servo4.write(angle_barriere);

				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(vitesse_barriere); // Vitesse angle barrière
			}
			
			//// Temporisation entre les groupes 1-3 et 2-4
			//for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
				//Fonction_feux(); // Appel de la fonction qui gère les feux
				//delay(1);
			//}
			
			//// Deuxième groupe servo 2 et 4
			//for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES
//
				//servo2.write(angle_barriere);
				//servo4.write(angle_barriere);
//
				//Fonction_feux(); // Appel de la fonction qui gère les feux
				//delay(vitesse_barriere); // Vitesse angle barrière
			//}
			barriere_ouverte = false;

		}
		if (premiere_detection == 1) {
			if (valeur_Detect2 < 512) {
				premiere_detection = 0;;
			}
		}
		if (premiere_detection == 2) { // Si non c'est que c'est le 2eme capteur
			if (valeur_Detect1 < 512) {
				premiere_detection = 0;
			}
		}
	}
	delay(50);
}
void Fonction_feux() {
	if (millis() > compteur_temps + tempo_led) {
		compteur_temps = millis();
		if (etat_feux == false) {
			etat_feux = true;
			digitalWrite(feu_droit,HIGH);
			digitalWrite(feu_gauche,HIGH);

			} else {
			etat_feux = false;
			digitalWrite(feu_droit,LOW);
			digitalWrite(feu_gauche,LOW);
		}
	}
}

A+
Cordialement
jpbbricole

j avais déjà essaye m mais pour être sur je viens de retester c est peut être la solution mais la c est a la fermeture qu il n y plus de décalè pas a l'ouverture

Excuses, je me suis croisé les pinceaux!

// C++ code
//
#include <Servo.h>
// Déclaration de constantes et variables
const int Detect1 = A0; // Détection 1 branchée sur l'entée A0
const int Detect2 = A1; // Détection 2 branchée sur l'entée A1
const int feu_droit = 13; // Première paire de feux
const int feu_gauche = 12; // Deuxième paire de feux
const int pulse_dfplayer = 11;
const int barriere1 = 8; // Fil signal servo1
const int barriere2 = 9; // Fil signal Servo2
const int barriere3 = 8; // Fil signal servo1
const int barriere4 = 9; // Fil signal Servo2
int tempo_fermeture = 4000; // temps clignotement avant fermeture barrières
int tempo_barrieres_13_24 = 10000; // temps entre les barrières 1-3 et 2-4
int tempo_led = 500; // tempo cligno
int angle_fermeture = 0; // angle servo position fermée
int angle_ouverture = 80; // angle servo position ouverte
int vitesse_barriere = 70; // temps entre 2 degrés
int inhibition = 10000; // Pendant cette durée le PN ne peut pas se redéclencher
int angle_barriere;
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
unsigned long compteur_temps;
boolean etat_feux = false; // Variable 0 si leds éteintes et 1 si allumées
int valeur_Detect1 = 1023; // Détecteur 1 ( + de 512 pas de détection. - de 512 détection.)
int valeur_Detect2 = 1023; // Détecteur 2
int premiere_detection = 0; // 1 si détecteur1 en premier, 2 si détecteur2 en premier.
boolean detection = false; // 0 si pas de détection. 1 si train détecté.
boolean barriere_ouverte; // 1 si barrières ouvertes.

void setup() {

	pinMode(feu_droit,OUTPUT);
	pinMode(feu_gauche,OUTPUT);
	pinMode(pulse_dfplayer,OUTPUT);
	digitalWrite(pulse_dfplayer,HIGH);

	servo1.attach(barriere1,500,2500);
	servo2.attach(barriere2,500,2500);
	servo1.write(angle_ouverture); //ouverture au début
	servo2.write(angle_ouverture);
	servo3.attach(barriere3,500,2500);
	servo4.attach(barriere4,500,2500);
	servo3.write(angle_ouverture); //ouverture au début
	servo4.write(angle_ouverture);
	barriere_ouverte = true;
}

void loop()
{
	valeur_Detect1 = analogRead(Detect1);
	valeur_Detect2 = analogRead(Detect2);
	if (detection == 1 && premiere_detection == 0) {
		if (valeur_Detect1 > 512 && valeur_Detect2 > 512) {
			digitalWrite(feu_droit,LOW);
			digitalWrite(feu_gauche,LOW);
			
			for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
				servo1.write(angle_barriere);
				servo3.write(angle_barriere);
				servo2.write(angle_barriere);
				servo4.write(angle_barriere);
				delay(vitesse_barriere);
			}
			
			// Temporisation entre les groupes 1-3 et 2-4
			for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			
			//for (int angle_barriere=angle_fermeture; angle_barriere<=angle_ouverture; angle_barriere+=1){ //OUVERTURE BARRIERES
				//servo2.write(angle_barriere);
				//servo4.write(angle_barriere);
				//delay(vitesse_barriere);
			//}
			
			barriere_ouverte = true;

			detection = 0;
			//digitalWrite(feu_droit,LOW);
			//digitalWrite(feu_gauche,LOW);
			delay(inhibition);
		}
	}
	// Permet de savoir quel détecteur est passé à l'état bas en premier
	if (detection == false) {
		// détection d'un train
		if (valeur_Detect1 < 512 || valeur_Detect2 < 512) {
			detection = true;
			digitalWrite(pulse_dfplayer,LOW);
			delay(100);
			digitalWrite(pulse_dfplayer,HIGH);
			// Mise en mémoire du détecteur.
			if (valeur_Detect1 < 512) {
				premiere_detection = 1;
				} else {
				premiere_detection = 2;
			}
		}
	}
	// Un train est détecté.
	else {

		Fonction_feux(); // Appel de la fonction qui gère les feux

		if (barriere_ouverte == true) {
			for (int tempo = 0; tempo <= tempo_fermeture; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			// Premier groupe servo 1 et 3
			for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES

				servo1.write(angle_barriere);
				servo3.write(angle_barriere);

				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(vitesse_barriere); // Vitesse angle barrière
			}
			
			// Temporisation entre les groupes 1-3 et 2-4
			for (int tempo = 0; tempo <= tempo_barrieres_13_24; tempo +=1){ // Temporisation avant fermeture
				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(1);
			}
			
			// Deuxième groupe servo 2 et 4
			for (int angle_barriere=angle_ouverture; angle_barriere>=angle_fermeture; angle_barriere-=1){ //FERMETURE BARRIERES

				servo2.write(angle_barriere);
				servo4.write(angle_barriere);

				Fonction_feux(); // Appel de la fonction qui gère les feux
				delay(vitesse_barriere); // Vitesse angle barrière
			}
			barriere_ouverte = false;

		}
		if (premiere_detection == 1) {
			if (valeur_Detect2 < 512) {
				premiere_detection = 0;;
			}
		}
		if (premiere_detection == 2) { // Si non c'est que c'est le 2eme capteur
			if (valeur_Detect1 < 512) {
				premiere_detection = 0;
			}
		}
	}
	delay(50);
}
void Fonction_feux() {
	if (millis() > compteur_temps + tempo_led) {
		compteur_temps = millis();
		if (etat_feux == false) {
			etat_feux = true;
			digitalWrite(feu_droit,HIGH);
			digitalWrite(feu_gauche,HIGH);

			} else {
			etat_feux = false;
			digitalWrite(feu_droit,LOW);
			digitalWrite(feu_gauche,LOW);
		}
	}
}

A+
Cordialement
jpbbricole

super je vient de teste c est magnifique je n ai plus qu a peaufiner 2/3 régalage et le rendue est a la hauteur de mes souhaitais voir encore mieux pille merci de ta sympathie

Bonjour hinano80

J'en suis ravi!
Bonne continuation!
Vive le train électrique, ça fait envie :wink:

Cordialement
jpbbricole

re bonjours a tous
après plusieurs essais deux petits problèmes apparaissent je vous les expose quand un train passe devant le premier détecteur il déclenche bien les barrières mais de qu il passe devant le deuxième il les fait ce relever donc faut je pense ajouter une temporisation avant pour que le train soit fin de passer .
deux comme je voudrai mettre deux voies sur ce passage a niveau il est donc nécessaire de mettre 4 détecteurs ( 2 par voies) donc permettre au programme de prendre en charge les 4 détecteurs avec des délais et des conditions pour que les barrières ne se relevé pas en cas de croisement de rame ferroviaire
par avance merci de vos solution

Il ne faut pas relever les barrières lorsque le train passe devant le 2nd capteur mais lorsqu'il a fini de passer. C'est-à-dire, on détecte la passage devant le capteur, puis la fin du passage et seulement là on relève les barrières.

Il faudrait mettre en place un comptage. Lorsqu'un train franchi le premier capteur, quelque soit le sens, tu fais +1 dans le compteur. Lorsqu'un train a franchi le second capteur tu fais -1 dans le compteur. Tu ne relèves les barrières que lorsqu'il y a 0 dans le compteur.

je vais essayer cette solution merci
je reviens vers vous des que s est en place

bonjour me revoilà avec mon problème j ai revu une partis du code mais je ne suis pas sur du résultat d autant que j ai un message lors du contrôle dans mon code je vous le soumet et espere votre aide merci par avance

passage_4_barriere_avec_compteur.ino (7,0 Ko)

Bonjour hinano80

Tu t'est pris, un peu, les pieds dans le tapis avec ton sketch :wink: , tu as 2 void loop() dont un imbriqué dans setup(), seul un est accepté.

Cordialement
jpbbricole

Bonjour,
Merci de copier/coller le code dans le corps du message (en le plaçant entre les balises ad hoc) au lieu de le mettre en pièce jointe. Car les personnes qui consultent le forum sur téléphone ou tablette ne peuvent pas le consulter facilement.