Le forum des passionnés de trains miniature, de petites autos etc etc
https://forum-passionnement.eu/
Hervé, bien que je ne lancerai pas dans l'impression de ton projet, c'est très sympa à toi de mettre tes Stl à notre disposition. 
. Je continue . . . C'est à dire ?
Liliane reprend du service. Super! c'est 
Code : Tout sélectionner
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * Pont transbordeur Voyageur * * * * * *
* * * * * * Commande verrouillage par servo * * * * * *
* * * * * * et * * * * * *
* * * * * * Commande Barrière par servo * * * * * *
* * * * * * * * * * * *
* * * * * * sur arduino Nano * * * * * *
* * * * * * avec condamnation verrou et barrière * * * * * *
* * * * * * et confimation du déverrouillage par fin de course * * * * * *
* * * * * * Le défaut de verrouilage entraine un blocage système * * * * * *
* * * * * * pour en sortir, faire un "RESET" * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Programme opérationnel
// Un servo pour le verrou et un pour la barrière
// deux entrée numérique commandent le servoV et le servoB
// entree niveau bas impose le verrou rentré et barrière levée
// entree niveau haut impose le verrou sorti et barrière baissée
#include <Servo.h>
const byte pinServoV = 2; // Servo commandant le verrouillage
const byte pinEntreeV = 5; // Entrée de commande verrou numérique D5 venant de la D25 du Méga
const byte pinServoB = 3; // Servo commandant la barrière
const byte pinEntreeB = 6; // Entrée de commande barrière numérique D6 venant de la Dxx du Méga
const byte pinVerrou = 7; // Sortie témoin de verrouillage - déverrouillage vers D27 du Méga
const byte pinBlocage = 9; // Entrée de condamnation du verrou
const byte pinFdc = 4; // Entrée du fin de course confirmant le déverrouillage
const byte pinDefaut = 8; // Sortie témoin de défaut de déverrouillage
int MiniMaxV[2] = {900,1700} ; // 900 = verrou rentré - 1700 = verrou sorti
int vitesseV[2] = {-1,1} ;
int MiniMaxB[2] = {830,2000} ; // 830 = barrière levée - 2000 = Barrière baissée
int vitesseB[2] = {-1,1} ;
Servo LeServoV; // variables pour le servo du verrou
int AvanceV;
int angleV;
int angleFinalV;
Servo LeServoB; // variables pour le servo de la barrière
int AvanceB;
int angleB;
int angleFinalB;
boolean Etat; // Etat de l'entrée de commande de verrouillage
boolean Etatlu;
boolean InverseV ; // Permet d'inverser la position du verrou par rapport à l'entrée
/*
* Ex: En supposant que "pinEntreeV = 0 " impose le verrou rentré avec "InverseV=false;"
* Alors il sera sorti si "InverseV=true;"
*/
boolean Temoin ;
boolean Barre; // Etat de l'entrée de commande de la barrière
boolean Barrelu;
boolean InverseB ; // Permet d'inverser la position de la barrière
boolean UneSeuleCmdt; // Permet de n'avoir qu'une entrée de commande
boolean MvtV;
boolean MvtB;
boolean Blocage; // Si "vrai" bloque le verrou en position déverrillé
boolean Fdc; // état du fin de course pour confirmation du déverrouillage
boolean Defaut; // vrai si le déverrouillage n'est pas confirmé
boolean Clign;
unsigned long Periode = 0 ;
void setup()
{
pinMode (pinEntreeV, INPUT);
pinMode (pinEntreeB, INPUT);
pinMode (pinVerrou, OUTPUT);
pinMode (pinBlocage, INPUT);
pinMode (pinFdc, INPUT);
pinMode (pinDefaut, OUTPUT);
LeServoV.attach(pinServoV);
LeServoV.writeMicroseconds(1300);
delay(500);
angleV = 1300;
AvanceV = vitesseV[false]; angleFinalV = MiniMaxV[false];
digitalWrite (pinDefaut,false);
Clign = false ;
Defaut = false ;
MvtV = true ;
MvtB = true ;
LeServoB.attach(pinServoB);
LeServoB.writeMicroseconds(1400);
delay(500);
angleB = 1400;
AvanceB = vitesseB[false]; angleFinalB = MiniMaxB[false];
UneSeuleCmdt = true ;
InverseV = false ;
InverseB = true ;
}
void loop()
{
Blocage = digitalRead(pinBlocage);
Etatlu = InverseV^digitalRead(pinEntreeV); Temoin = Etatlu ;
Barrelu = InverseB^digitalRead(pinEntreeB);
if(Blocage) { Etatlu =InverseV ^ false ; Barrelu = InverseB^false ; }
if(UneSeuleCmdt) { Barrelu = InverseB^Etatlu ; }
if(MvtV) { }
else {
if (Etatlu == Etat ) { }
else{
Etat = Etatlu ;
LeServoV.attach(pinServoV);
AvanceV = vitesseV[Etat]; angleFinalV = MiniMaxV[Etat];
MvtV = true ;
}
}
if(MvtB) { }
else {
if (Barrelu == Barre ) { }
else{
Barre = Barrelu ;
LeServoB.attach(pinServoB);
AvanceB = vitesseB[Barre]; angleFinalB = MiniMaxB[Barre];
MvtB = true ;
}
}
angleV = angleV + AvanceV;
LeServoV.writeMicroseconds(angleV);
Fdc = digitalRead(pinFdc);
if (angleV == angleFinalV)
{
AvanceV = 0;
LeServoV.detach();
MvtV = false ;
}
angleB = angleB + AvanceB;
LeServoB.writeMicroseconds(angleB);
if (angleB == angleFinalB)
{
AvanceB = 0;
LeServoB.detach();
MvtB = false ;
}
if(!MvtV) {
if (Temoin) {digitalWrite (pinVerrou,Temoin);}
if (!Temoin && Fdc ) {digitalWrite (pinVerrou,Temoin); Defaut = false ;}
if (!Etat && !Fdc ) { Defaut = true ; }
if (Defaut){while(true){
if(millis()-Periode > 100 ){Clign = !Clign ; Periode = millis(); }
digitalWrite (pinDefaut,Clign);
}
}
}
else { digitalWrite (pinDefaut,LOW); }
delay(3);
}