Interlocking ou enclenchement en français dans le texte.
Je vous laisse vous reporter si nécessaire aux informations disponibles à ce sujet sur Wikipédia.
Quel est mon objectif ?
Reproduire avec un Arduino un tableau de commande intégrant un dispositif d'enclenchement
Entrée : Bouton poussoir
Sortie : +5V
Pour concevoir une table d'enclenchement, une lecture s'impose : Trax 3 de Jeff Geary
Voici donc le 1er programme :
// Tableau de commande avec table d'enclenchement
// Fabrice Fayolle - Février 2014
// Entrées : Port de 13 à 7
int e0 = 13;
// Sorties : Port de 0 Ã 6
int s0 = 0;
int e1 = 12;
int s1 = 1;
int e2 = 11;
int s2 = 2;
int e3 = 10;
int s3 = 3;
int e4 = 9;
int s4 = 4;
int e5 = 8;
int s5 = 5;
int e6 = 7;
int s6 = 6;
//nb : nombre de commandes disponibles
int nb = 7;
// levier[] : tableau permettant de connaître la position du levier (0 pour normal ; 1 pour reverse)
int levier[7]={0,0,0,0,0,0,0};
// verrouillage[] : tableau permettant de connaître l'état d'un levier (0 pour Not Lock)
int verrouillage[7]={0,0,0,0,0,1,1};
// mat[] : table d'enclenchement (1 pour Lock; -1 pour Release; sinon 0)
//Exemple : Si 1 Lock 2 alors ligne 1 est 0,1,0,0,0,0,0 et ligne 2 est 1,0,0,0,0,0,0
int mat[49]={
0,1,1,1,1,0,1,
1,0,1,1,0,0,0,
1,1,0,0,0,0,0,
1,1,0,0,0,-1,0,
1,0,0,0,0,0,-1,
1,1,1,1,0,0,0,
1,0,0,0,1,0,0};
void setup()
{
//Initialisation des entrées et des sorties
pinMode( e0, INPUT );
digitalWrite( e0, HIGH );
pinMode( s0, OUTPUT );
digitalWrite( s1, LOW );
pinMode( e1, INPUT );
digitalWrite( e1, HIGH );
pinMode( s1, OUTPUT );
digitalWrite( s2, LOW );
pinMode( e2, INPUT );
digitalWrite( e2, HIGH );
pinMode( s2, OUTPUT );
digitalWrite( s2, LOW );
pinMode( e3, INPUT );
digitalWrite( e3, HIGH );
pinMode( s3, OUTPUT );
digitalWrite( s3, LOW );
pinMode( e4, INPUT );
digitalWrite( e4, HIGH );
pinMode( s4, OUTPUT );
digitalWrite( s4, LOW );
pinMode( e5, INPUT );
digitalWrite( e5, HIGH );
pinMode( s5, OUTPUT );
digitalWrite( s5, LOW );
pinMode( e6, INPUT );
digitalWrite( e6, HIGH );
pinMode( s6, OUTPUT );
digitalWrite( s6, LOW );
}
void loop()
{
int decalage = 0;
//decalage : variable permettant de calculer le décalage nécessaire à la lecture de la table d'enclenchement
if ( digitalRead( e0 ) == LOW && verrouillage[0] == 0)
//Si l'entrée x est à Low et que le levier n'est pas bloqué (Not Lock) alors
{
delay( 100 );
while ( digitalRead( e0 ) == LOW )
{
delay( 100 );
}
//Correction du phénomène de rebond
decalage = 0 * nb;
if (levier[0] == 0)
//Si le levier x est en position Normal
{
digitalWrite( s0, HIGH );
//Sortie x à l'état High
levier[0] = 1;
//Levier en position Reverse
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
//Application de la table d'enclenchement pour l'ensemble des leviers
}
else
{
digitalWrite( s0, LOW );
//Sortie x à l'état Low
levier[0] = 0;
//Levierx en position Normal
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
//Suppression de l'application de la table d'enchenchement pour l'ensemble des leviers
}
}
if ( digitalRead( e1 ) == LOW && verrouillage[1] == 0)
{
delay( 100 );
while ( digitalRead( e1 ) == LOW )
{
delay( 100 );
}
decalage = 1 * nb;
if (levier[1] == 0)
{
digitalWrite( s1, HIGH );
levier[1] = 1;
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
}
else
{
digitalWrite( s1, LOW );
levier[1] = 0;
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
}
}
if ( digitalRead( e2 ) == LOW && verrouillage[2] == 0)
{
delay( 100 );
while ( digitalRead( e2 ) == LOW )
{
delay( 100 );
}
decalage = 2 * nb;
if (levier[2] == 0)
{
digitalWrite( s2, HIGH );
levier[2] = 1;
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
}
else
{
digitalWrite( s2, LOW );
levier[2] = 0;
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
}
}
if ( digitalRead( e3 ) == LOW && verrouillage[3] == 0)
{
delay( 100 );
while ( digitalRead( e3 ) == LOW )
{
delay( 100 );
}
decalage = 3 * nb;
if (levier[3] == 0)
{
digitalWrite( s3, HIGH );
levier[3] = 1;
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
}
else
{
digitalWrite( s3, LOW );
levier[3] = 0;
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
}
}
if ( digitalRead( e4 ) == LOW && verrouillage[4] == 0)
{
delay( 100 );
while ( digitalRead( e4 ) == LOW )
{
delay( 100 );
}
decalage = 4 * nb;
if (levier[4] == 0)
{
digitalWrite( s4, HIGH );
levier[4] = 1;
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
}
else
{
digitalWrite( s4, LOW );
levier[4] = 0;
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
}
}
if ( digitalRead( e5 ) == LOW && verrouillage[5] == 0)
{
delay( 100 );
while ( digitalRead( e5 ) == LOW )
{
delay( 100 );
}
decalage = 5 * nb;
if (levier[5] == 0)
{
digitalWrite( s5, HIGH );
levier[5] = 1;
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
}
else
{
digitalWrite( s5, LOW );
levier[5] = 0;
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
}
}
if ( digitalRead( e6 ) == LOW && verrouillage[6] == 0)
{
delay( 100 );
while ( digitalRead( e6 ) == LOW )
{
delay( 100 );
}
decalage = 6 * nb;
if (levier[6] == 0)
{
digitalWrite( s6, HIGH );
levier[6] = 1;
for (int i = 0; i <nb;i++)
{
verrouillage[i] += mat[decalage+i];
}
}
else
{
digitalWrite( s6, LOW );
levier[6] = 0;
for (int i = 0; i <nb;i++)
{
verrouillage[i] -= mat[decalage+i];
}
}
}
}
En utilisant une platine d'essai, j'ai fait un montage très simple qui se passe de commentaire (tout a déjà été dit sur ce sujet dans les autres fils. Merci aux différents auteurs!!!) et qui permet de vérifier le bon fonctionnement du dispositif.
Le plan succinct de la gare :
Des commentaires ?