Arduino et incompatibilité de manoeuvre (enclenchement)

[FFayolle]

Bonjour,

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 ?

[HDE5962]

Bonjour Ffayolle,

c'est du lourd que tu envois ici,

faire un TCO de gestion des enclenchements est une excellente idée.
Peux tu pour nos camarades qui ne parlent pas ou peu l'anglais détailler ton projet avec un peu plus de commentaires ou simplement nous faire une vidéo de celui-ci dans son cadre final.

Je n'ai pas regardé dans la profondeur chaque instruction qui en lecture rapide de ton programme me semble logique.

je l'étudierai plus en profondeur mais pas pour l'instant.

Tu aurais donc 7 entrées équipés de BP nommés de E1 à E7
Tu aurais aussi 7 sortie pour allumer les leds de ton TCO nommés de S1 à S7

En fonction du BP sur lequel une action est faite, tu changes l'état des leds suivant ta matrice générée dans le programme.

Dis moi si je me trompe.

AS tu prévu de faire fonctionner tes aiguilles en même temps que l'appuie sur le BP et la mise en séquence des leds du TCO.

Cousin Hub,

[FFayolle]

Merci!!!

Tu as tout à fait compris l'objectif du programme sachant qu'aujourd'hui ceux ne sont que des LEDs qui s'allument mais si on les remplace par un circuit de puissance (TIP222 ou le fameux ULN2003 par exemple puis relais 2RTavec alimentation 12VDC), on pourra donc alimenter des moteurs d'aiguillage et de signaux (voire couper l'alimentation de la voie).

Les enclenchements (ou interlocking en anglais) permettent d'empêcher certains mouvements d'aiguilles et/ou de signaux pour assurer la sécurité des circulations. La matrice permet donc de lister les incompatibilités.

Le programme :

Je suis à l'écoute de toutes les entrées (les boutons poussoirs).

Si une entrée est activé (mise à LOW de l'entrée), alors je vérifie que je peux modifier la position de mon aiguille ou de mon signal (est-il non bloqué, non verrouillé? Informations disponibles dans le tableau verrouillage[])

Si, je peux modifier la position de mon aiguille ou de mon signal, alors suivant sa position actuelle (informations disponibles dans le tableau levier[]),

1) je modifie la position de l'aiguille ou du signal (activation ou non de la sortie, modification du tableau levier[])

2)je lis la ligne de la matrice pour activer ou désactiver les incompatibilités (informations disponibles dans le tableau mat[]) pour modifier l'état (verrouillé ou non? (lock or not?)) de chaque aiguille ou signal (modification des valeurs du tableau verrouillage[])

Tous les cas de figure ne sont pas aujourd'hui encore traités. Restons simple!!!

Un exemple :



Voici la table correspondante à ce schéma :

...
int mat[49]={
0,1,1,1,1,1,0,
1,0,1,1,0,0,0,
1,1,0,1,0,0,0,
1,1,1,0,0,0,0,
1,0,0,0,0,-1,0,
1,0,0,0,1,0,0,
0,0,0,0,0,0,0};

void setup()
{
...

Prenons par exemple la 1ère ligne de la matrice :
0,1,1,1,1,1,0,
Elle correspond aux verrouillages qui seront nécessaires si je modifie la position de mon signal 1 (voir schéma ci-dessus, signal permettant l'accès en gare), en un mot, si je donne voie libre.
Si le signal 1 est ouvert, alors je ne dois pas pouvoir modifier la position (et donc je bloque (lock)),
le levier 2 qui correspond à une aiguille donnant accès à une voie de service
le levier 3 ...
le levier 4 qui correspond au signal en sens inverse
...

[HDE5962]

tu pourrais aussi rester dans le monde Arduino et avec un Attiny, gérer des servos en 5V qui commanderai à la fois les led du TCO et les aiguilles et qui pourrait par le biai des transistor NPN couper l'alimentation des secteurs.

Dans tous les cas, ton travail est excellent et mérite d'être présenté avec plus de détails pour nos amis du Forum. Il faut penser qu'ils ne sont pas tous informaticien ni électronicien et que toute l'aide doit leur être apportée pour qu'ils puissent s'approprier ton programme.

[FFayolle]

Merci pour l'information mais je suis plutôt Tortoise ou Cobalt.
Le dinosaure!!!


Si l'on regarde de plus près le programme principal, on s'aperçoit qu'il y a 7 fois le même bloc à une différence près, le numéro d'entrée et de sortie concerné.

Le bloc :

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
}
}

J'ai mis en gras ce qui changeait dans les différents blocs. Pour rappel, le levier n°1 correspond à la position 0 (entrée e0 et sortie associée s0),...

[Arduino]

Bonjour Fabrice,

Hubert a raison et si je peux me permettre une remarque, ton projet est intéressant mais sa présentation manque de convivialité. A la première lecture de ton post, je n'ai guère eu envie d'approfondir pour plusieurs raisons.

Tes références renvoient à un livre (anglais) que les gens ne possèdent pas forcément, ce qui fait qu'on peut être un peu perdu dans tes conventions pour l'écriture de ton programme.

Ton listing de programme est long et n'est pas présenté comme on le fait tous dans ce forum. Pour joindre un programme, tu pars de l'environnement de développement d'Arduino et tu vas dans le menu Edition, -> Copier pour le forum. Ton programme est alors dans le presse-papier et il te suffit ensuite de le coller (CTRL + V). Sa présentation en couleur avec les conventions d'écriture fait qu'il est plus agréable à lire et à comprendre.

Enfin, ta photo est intéressante mais où sont les poussoirs et où vont tous ces fils non branchés ? Crois-moi, un schéma vaut mieux qu'un long discours et tu peux en faire facilement avec l'application gratuite fritzing (il y a tous les composants possibles qu'il suffit de déplacer sur une breadboard, et c'est très facile à utiliser).

Bien sûr, ce ne sont que quelques conseils, cela ne retire rien à ton projet que je comprends mieux aujourd'hui. Bon courage.

Christian

[FFayolle]

Christian,

Si je te l'accorde, tout le monde n'a pas le livre de Jeff Geary, tout le monde peut déjà lire l'article sur les enclenchements disponible sur Wikipédia.

Ce programme a été fait en parcourant les différents fils sur le sujet, et lisant les articles parus dans Loco Revue et en m'inspirant de différents programmes disponibles sur le site Ligne secondaire du Sud-Est.

Je reprends donc en tenant compte de tes remarques et de celles d'Hubert.

Le code source :

// Tableau de commande avec table d'enclenchement
// Fabrice Fayolle - Février 2014 - Version 1
// 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,0};
// 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,1,0,
1,0,1,1,0,0,0,
1,1,0,1,0,0,0,
1,1,1,0,0,0,0,
1,0,0,0,0,-1,0,
1,0,0,0,1,0,0,
0,0,0,0,0,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];
      }
    }
  }
}

La suite dans un prochain post...

[HDE5962]

Ha oui, au fait, une des rêgles du principe fondamental de ce Forum que nous avons voulus au début avec Christian.

Change le nom de ton sujet et intégre la notion de Arduino dans le Titre.
regardes un peu les autres fils.

Je pense que "Arduino et la gestion d''un TCO de gare" serait un bon titre mais c'est toi qui voit.

Cousin Hub

[FFayolle]

Ha oui, au fait, une des rêgles du principe fondamental de ce Forum que nous avons voulus au début avec Christian.

Change le nom de ton sujet et intégre la notion de Arduino dans le Titre.
regardes un peu les autres fils.

Je pense que "Arduino et la gestion d''un TCO de gare" serait un bon titre mais c'est toi qui voit.

Cousin Hub

Arduino et incompatibilité de manoeuvre (enclenchement)

A me répéter, pour les néophytes sur le sujet (et ce n'est pas une critique), la lecture de l'article disponible sur Wikipédia est vivement recommandé.

[Arduino]

Ton programme est beaucoup plus lisible comme cela ; les lecteurs se sentent chez eux puisqu'ils ont l'habitude de voir des listings comme cela avec Arduino.

Ce n'est plus la peine de nommer ton forum avec le nom d'Arduino ; cette règle avait été fixée pour qu'on s'y retrouve avant qu'un forum spécialisé Arduino soit créé par le modérateur. Mais c'est vrai que mettre Arduino dans le titre a l'avantage de bien préciser qu'on utilise Arduino pour traiter le sujet. Je ne sais pas si c'est simple de changer le titre d'un forum ; alors ne te casse pas la tête pour cette fois.

Pour ton projet, tu peux consulter le forum de PICO qui a fait une butte de triage, un peu sur le même principe (même s'il n'y a pas à vérifier les conditions d'enclenchement). C'est un travail super de sa part.

As-tu été voir le logiciel fritzing ? C'est vraiment très simple pour publier un schéma type breadboard.

Bon courage pour la réalisation ; on reste à ta disposition si nécessaire.

[FFayolle]

Les différents fils sont une mine d'or. Merci!!!

En parcourant ce post, je viens donc de m'apercevoir que je pouvais utiliser les entrées analogiques pour mes boutons poussoir et que je n'avais pas 6 entrées mais 1024/x entrées en utilisant le principe de diviseur de tension.

J'ai donc en fait la possibilité de simuler avec un Arduino Uno un poste d'aiguillage à 14 leviers. J'en entends déjà qui disent que si on utilise le multiplexage, on pourra encore accroître les possibilités. Mais faisons simple!!!

Une question pour les experts :
Est-ce que la mise à Low du port Reset réinitialise la carte Arduino Uno, svp ?
Je voudrais juste prévoir cette commande sur le tableau.

[FFayolle]

Et si on reprenait le tout depuis le début car le plus difficile n'est-il pas de transformer un système quelqu'il soit en un programme.



Sur une voie unique pouvant être parcourue dans les 2 sens, un signal (sémaphore) est implanté dans chaque sens de circulation. Sans dispositif particulier, rien n'empêcherait d'ouvrir les 2 sémaphores.
Catastrophe!!!


Quelles sont les règles que le dispositif doit respecter ?
Si le signal 1 est ouvert, alors le signal 2 est fermé
Si le signal 2 est ouvert, alors le signal 1 est fermé

Remarque importante : non prise en compte de la présence ou non d'un train pour l'instant

Ce qui pourrait se traduire par
Le signal 1 bloque le signal 2
Le signal 2 bloque le signal 1

Si l'on retranscrit le tout dans une matrice, on obtient le résultat suivant :



Règles d'écriture : L pour bloque

Un autre exemple dans un prochain post. Et n'hésitez pas à commenter si nécessaire

[FFayolle]

Quelles sont les règles que le dispositif doit respecter?
Si le signal 1 est ouvert, alors le signal 2 est fermé et le signal 3 est fermé
Si le signal 1 est ouvert, alors il n'est pas possible de manœuvrer l'aiguille 4
Si le signal 2 est ouvert, alors il n'est pas possible de manœuvrer l'aiguille 4
Si le signal 3 est ouvert, alors il n'est pas possible de manœuvrer l'aiguille 4
Si l'aiguille 4 est fermé (la position par défaut, c'est à dire normal), alors le signal 3 est fermé
Si l'aiguille 4 est ouverte (c'est à dire dévié), alors le signal 2 est fermé

Pour simplifier, je ne vais pas lister les règles symétriques du type "Si le signal 2 est ouvert, alors le signal 1 est fermé et le signal3 est fermé".

Si l'on retranscrit le tout dans une matrice, on obtient le résultat suivant :



Règles d'écriture : L pour bloque (Lock); R pour permet la manœuvre du levier, le débloque (Release)

Pourquoi R et non L dans la case 4:3 (ligne 4 : colonne 3) ?

Comme vu ci-dessus, le signal 3 ne pourra être ouvert que si l'aiguille 4 est fermée. On dit alors que la fermeture de l'aiguillage 4 permet la manœuvre du signal 3.

A suivre...

[FFayolle]

Une question pour les experts :

Puis-je écrire cela

  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 );

sous la forme d'une boucle de type for ?

D'avance merci

[Arduino]

Ah ! Là, j'adore !

Parce que c'est expliqué très clairement !

Tu dis que le plus difficile est de transformer un système quel qu'il soit en programme. D'après moi, pas tout à fait . Le plus difficile est le travail d'analyse qui consiste à décortiquer ce que doit réaliser le système (sans rien oublier), déterminer quelles sont les variables d'entrée et quelles sont celles de sorties, valider ces variables pour ne pas tomber dans des cas aberrants, analyser les ressources nécessaires (taille du système donc choix du module), etc.

Ce travail ne se fait pas devant l'ordinateur. Or l'erreur de beaucoup de débutants est de se mettre à produire des lignes de code sans trop avoir approfondi le travail d'analyse ... et comme cela ne marche pas du premier coup, on met des patches par ci par là !

Si le travail d'analyse est bien réalisé, le programme coule de lui-même. C'est comme une rédaction, si tu as un bon plan, le récit vient de lui-même .