Piloter un relais bistable avec Arduino

On est d'accord que si on veut gérer plusieurs systèmes en même temps, on ne peut pas utiliser delay()

En effet, si par exemple on est en train de détecter un train sur une des voies tout en en détectant un autre sur une autre voie, il faut que les automates des deux détections avancent en même temps.

Ceci est permis par les automates de détection qu'on a vus auparavant. Le programme fait avancer les 4 automates en même temps et aucun d'entre eux n'a de delay() qui bloquerait tous les autres

Le seul delay() permis est celui qui est à la fin de loop. Il est interdit d'utiliser des delay() ailleurs

Donc pour générer les impulsion de commande, on ne peut pas utiliser delay() pour compter le temps de maintien de l'impulsion à HIGH. Pour cela il faut aussi faire une automate avec un compteur pour compter le temps qui s'écoule (en terme de ticks de 10ms) quand l'impulsion est envoyée.

Ok ce coup-ci j'ai compris le principe !

Ok   

Voyons le programme.

Comme pour l'automate de détection de train dans la gare, la traduction de l'automate en Arduino est assez directe. On a besoin d'une variable pour stocker l'état : etatAiguille, d'une variable pour le compteur : compteurAiguille et enfin d'une variable pour la commande d'aiguille : commandeAiguille.

Cette dernière variable est une garde de l'automate de gestion d'aiguille et une action de l'automate de détection de train et permet aux deux automates de communiquer.

Dans le système on a 4 gares et 2 (paires d') aiguilles, on a donc 4 automates de détection de train et 2 automates de gestion d'aiguille. Par conséquent pour les automates de gestion d'aiguille on a les déclarations suivantes :

Citation :

// les états que l'automate d'aiguille peut prendre
enum { DEVIEE, DROITE, PULSE_DEVIEE, PULSE_DROITE };

byte etatAiguille[2] = {DROITE, DROITE};
byte compteurAiguille[2];
byte commandeAiguille[2] = {DROITE, DROITE};

const unsigned long dureeImpulsion = 10; // valeur arbitraire, à ajuster

Dans l'automate, on avait mis des gardes symboliques : position_deviee et position_droite. Maintenant qu'elle sont associées au contenu de la variable commandeAiguille, on peut faire la substitution dans l'automate :



Pour pouvoir effectivement manœuvrer les aiguilles on a besoin de savoir sur quelles pins elles sont raccordées. On va faire ça au moyen de 2 tableaux :

Citation :

const byte pinDroite[2] = {6, 8};
const byte pinDeviee[2] = {7, 9};

Dans setup(), il faut mettre les aiguilles dans un état initial connu. On a décidé arbitrairement que cet état initial était DROITE. Donc :

Citation :

  int aiguille;
  
  for (aiguille = 0; aiguille < 2; aiguille++) {
    // les deux pins de commande sont mises à LOW
    digitalWrite(pinDeviee[aiguille], LOW);
    digitalWrite(pinDroite[aiguille], LOW);
    // les deux pins de commande sont mises en sortie
    pinMode(pinDeviee[aiguille], OUTPUT);
    pinMode(pinDroite[aiguille], OUTPUT);
    // et on met une impulsion sur la commande droite
    // pour mettre l'aiguille en position initiale connue
    digitalWrite(pinDroite[aiguille], HIGH);
    delay(dureeImpulsion);
    digitalWrite(pinDroite[aiguille], LOW);
  }

L'automate est traduit en un switch ... case

Citation :

  int aiguille;
  
  for (aiguille = 0; aiguille < 2; aiguille++) {
    switch (etatAiguille[aiguille]) {
      case DEVIEE:
        if (commandeAiguille[aiguille] == DROITE) {
          // commande pour mettre l'aiguille DROITE
          compteurAiguille[aiguille] = 0;
          // commande pour mettre l'aiguille DROITE
          digitalWrite(pinDroite[aiguille], HIGH);
          // on va dans l'état PULSE_DROITE
          etatAiguille[aiguille] = PULSE_DROITE;
        }
        break;
      case DROITE:
        if (commandeAiguille[aiguille] == DEVIEE) {
          // commande pour mettre l'aiguille DEVIEE
          compteurAiguille[aiguille] = 0;
          // commande pour mettre l'aiguille DROITE
          digitalWrite(pinDeviee[aiguille], HIGH);
          // on va dans l'état PULSE_DEVIEE
          etatAiguille[aiguille] = PULSE_DEVIEE;
        }
        break;
      case PULSE_DEVIEE:
        if (compteurAiguille[aiguille] < dureeImpulsion) {
          // on reste dans PULSE_DEVIEE pendant dureeImpulsion ticks
          compteurAiguille[aiguille]++;
        }
        else {
          // transition vers l'état DEVIEE, on coupe le pulse
          digitalWrite(pinDeviee[aiguille], LOW);
          etatAiguille[aiguille] = DEVIEE;
        }
        break;
      case PULSE_DROITE:
        if (compteurAiguille[aiguille] < dureeImpulsion) {
          // on reste dans PULSE_DROITE pendant dureeImpulsion ticks
          compteurAiguille[aiguille]++;
        }
        else {
          // transition vers l'état DROITE, on coupe le pulse
          digitalWrite(pinDroite[aiguille], LOW);
          etatAiguille[aiguille] = DROITE;
        }
        break;
    }
  }        

Il reste maintenant à faire le lien entre les 4 automates de détection de train et les deux automates de commande des aiguilles via le tableau de variable commandeAiguille

Merci Jlb, je vais essayer de "digérer" ce que tu viens d'envoyer !!

Pendant que je te laissais cogiter lâchement sur le programme, je me suis penché sur le câblage de l'aiguillage en utilisant mon mini programme Arduino initial bien sûr !

J'ai modifié le branchement afin de tenir compte des différentes remarques et notamment de la tienne proposant de mettre en parallèle un autre 2N2222 pour l'aiguillage et j'ai mis en test le schéma ci-dessous :

" />

Mais si le relais continue bien à fonctionner, il ne se passe rien au niveau de l'aiguillage, à part un vague bruit de bobine au moment de la mise sous tension générale.

A préciser que le moteur fonctionne tout à fait normalement si je le teste directement sur le 16V redressé.

Ai-je fait une erreur dans mon câblage ?

Si je ne me trompe pas, le courant Base Emetteur est de 2,15mA. Le 2N2222 a un gain maxi de 300 (ça varie beaucoup mais c'est max 300 et min 100). Donc le courant Collecteur Emetteur est entre 2,15 * 100 = 215 mA et 2,15 * 300 = 645mA, ce qui est peut être insuffisant pour que le moteur d'aiguille bouge.

Avec les mesures de résistance que tu avais faites plus haut, entre 6 et 8 Ω, sous 16V, ça donne un courant de 2A. Le 2N2222 passe 800mA maxi. Donc il faut un transistor plus costaud, pas exemple un BD 675A, 677A, 679A ou BD681 qui passe 4A voire 6 en impulsion (la différence entre les 4 transistors est la tension maxi Collecteur Emetteur qui s'échelonne de 45 à 100V). Ces transistors on un gain de 750 et donc avec 1kΩ et le 2N2222 qui prend la moitié du courant, ça donnera un courant maxi de (5v - 0,7v)/1000/2 * 750 = 1,61A ce qui devrait suffire

Par ailleurs, quelle est la durée de ton pulse ?

jlb a écrit:

Donc il faut un transistor plus costaud, pas exemple un BD 675A, 677A, 679A ou BD681 qui passe 4A voire 6 en impulsion

J'ai pas ces bêtes dans mon "bazar", il va falloir différer un peu le test, le temps que j'aille voir mon fournisseur préféré.....  

Citation :

Par ailleurs, quelle est la durée de ton pulse ?

Il était à 5 millis, j'ai essayé de passer à une seconde pour voir.
Seule différence notable on entend nettement la bobine bourdonner, mais rien ne se passe de plus en mouvement. Je pense que çà confirme le manque de puissance ?


Sinon mon schéma est exact ? Et pas de changement nécessaire sur la résistance, ni sur les diodes roue libre ?

Bon maintenant je vais de ce pas, ......me plonger dans ton code  

Effectivement le courant n'est pas assez fort.

Rien à changer sur ton schéma

Et bien, j'ai tout compris de ton code avec une facilité déconcertante !     Il est vrai que çà reprend le même schéma que le premier automate, et que là j'y avais passé beaucoup plus de temps     

Une simple petite question : J'ai remarqué que tu reprenais toujours dans tes Switch ..Case le même ordre de cas que dans l'enum initial. Est-ce par facilité de lecture du programme ou une stricte obligation de syntaxe ?

Et dire que grâce à ton aide je vais bientôt ressembler à çà :     

VAUBAN38 a écrit:

Et bien, j'ai tout compris de ton code avec une facilité déconcertante !     Il est vrai que çà reprend le même schéma que le premier automate, et que là j'y avais passé beaucoup plus de temps     

J'ai fait exprès, c'est le même modèle de conception

Citation :

Une simple petite question : J'ai remarqué que tu reprenais toujours dans tes Switch ..Case le même ordre de cas que dans l'enum initial. Est-ce par facilité de lecture du programme ou une stricte obligation de syntaxe ?

Il n'y a pas d'obligation d'ordre. J'avais l'ordre dans la tête et c'est sorti comme ça.

La communication entre les deux automates :

Nous avons donc nos 4 gares numérotées 0, 1, 2 et 3 et nos deux paires d'aiguilles numérotées 0 et 1.

La paire 0 correspond aux gares 0 et 1

La paire 1 correspond aux gares 2 et 3

Pour calculer le numéro d'aiguille à partir du numéro de gare, il suffit de diviser le numéro de gare par 2. Il s'agit d'une division entière.

Pour aller dans la gare 0, il faut que la paire d'aiguille 0 soit DROITE
Pour aller dans la gare 1, il faut que la paire d'aiguille 0 soit DEVIEE

Pour aller dans la gare 2, il faut que la paire d'aiguille 1 soit DROITE
Pour aller dans la gare 3, il faut que la paire d'aiguille 1 soit DEVIEE

Donc

Quand on détecte un train gare 0, il faut mettre la paire d'aiguille 0 en DEVIEE (pour que la gare 1 soit sélectionnée pour le prochain train)
Quand on détecte un train gare 1, il faut mettre la paire d'aiguille 0 en DROITE (pour que la gare 0 soit sélectionnée pour le prochain train)

Quand on détecte un train gare 2, il faut mettre la paire d'aiguille 0 en DEVIEE (pour que la gare 3 soit sélectionnée pour le prochain train)
Quand on détecte un train gare 3, il faut mettre la paire d'aiguille 0 en DROITE (pour que la gare 2 soit sélectionnée pour le prochain train).

On établit donc une table qui à un numéro de gare fait correspondre la commande d'aiguille :

Citation :

// tableau indexé par le numéro de gare qui donne la position de l'aiguille associée
const byte commandeDeGareAAiguille[4] = {DEVIEE, DROITE, DEVIEE, DROITE};

Il suffit maintenant d'exploiter cette table dans les automates de détection de train sur la transition ATTELAGE->ATTENTE pour mettre une valeur dans la table commandeAiguille qui est exploité par les automate de gestion des aiguilles. Comme ceci :

Citation :

            commandeAiguille[gare / 2] = commandeDeGareAAiguille[gare];

Voici donc le programme complet mais qui n'est pas testé. Dans loop() on fait fonctionner les 4 automates de détection de train puis les deux automates de commande des aiguilles, tout cela toutes les 10 ms :

Citation :

// les états que l'automate de détection de train peut prendre
enum { ATTENTE, WAGON, ATTELAGE };

const int pinsCapteur[4] = {2, 3, 4, 5};
byte etatTrain[4] = {ATTENTE, ATTENTE, ATTENTE, ATTENTE};
byte compteur[4];

const unsigned long dureeAttelage = 50;

// les états que l'automate d'aiguille peut prendre
enum { DEVIEE, DROITE, PULSE_DEVIEE, PULSE_DROITE };

byte etatAiguille[2] = {DROITE, DROITE};
byte compteurAiguille[2];
byte commandeAiguille[2] = {DROITE, DROITE};

// tableau indexé par le numéro de gare qui donne la position de l'aiguille associée
const byte commandeDeGareAAiguille[4] = {DEVIEE, DROITE, DEVIEE, DROITE};

const byte pinDroite[2] = {6, 8};
const byte pinDeviee[2] = {7, 9};

const unsigned long dureeImpulsion = 10; // valeur arbitraire, à ajuster

void setup()
{
  int gare;
  
  for (gare = 0; gare < 4; gare++) {
    pinMode(pinsCapteur[gare], INPUT);
  }
  
  int aiguille;
  
  for (aiguille = 0; aiguille < 2; aiguille++) {
    // les deux pins de commande sont mises à LOW
    digitalWrite(pinDeviee[aiguille], LOW);
    digitalWrite(pinDroite[aiguille], LOW);
    // les deux pins de commande sont mises en sortie
    pinMode(pinDeviee[aiguille], OUTPUT);
    pinMode(pinDroite[aiguille], OUTPUT);
    // et on met une impulsion sur la commande droite
    // pour mettre l'aiguille en position initiale connue
    digitalWrite(pinDroite[aiguille], HIGH);
    delay(dureeImpulsion);
    digitalWrite(pinDroite[aiguille], LOW);
  }
}

void loop()
{
  int gare;
  
  for (gare = 0; gare < 4; gare++) {
    
    byte capteur = digitalRead(pinsCapteur[gare]);
  
    switch (etatTrain[gare])
    {
      case ATTENTE:
        if (capteur == LOW) {
          etatTrain[gare] = WAGON;
        }
        break;
      case WAGON:
        if (capteur == HIGH) {
          etatTrain[gare] = ATTELAGE;
          compteur[gare] = 0;
        }
        break;
      case ATTELAGE:
        if (capteur == LOW) {
          etatTrain[gare] = WAGON;
        }
        else {
          if (compteur[gare] < dureeAttelage) {
            compteur[gare]++;
          }
          else {
            etatTrain[gare] = ATTENTE;
            // commande l'aiguille associée pour sélectionner la gare associée
            commandeAiguille[gare / 2] = commandeDeGareAAiguille[gare];
          }
        }
        break;
    }
  }
  
  int aiguille;
  
  for (aiguille = 0; aiguille < 2; aiguille++) {
    switch (etatAiguille[aiguille]) {
      case DEVIEE:
        if (commandeAiguille[aiguille] == DROITE) {
          // commande pour mettre l'aiguille DROITE
          compteurAiguille[aiguille] = 0;
          // commande pour mettre l'aiguille DROITE
          digitalWrite(pinDroite[aiguille], HIGH);
          // on va dans l'état PULSE_DROITE
          etatAiguille[aiguille] = PULSE_DROITE;
        }
        break;
      case DROITE:
        if (commandeAiguille[aiguille] == DEVIEE) {
          // commande pour mettre l'aiguille DEVIEE
          compteurAiguille[aiguille] = 0;
          // commande pour mettre l'aiguille DROITE
          digitalWrite(pinDeviee[aiguille], HIGH);
          // on va dans l'état PULSE_DEVIEE
          etatAiguille[aiguille] = PULSE_DEVIEE;
        }
        break;
      case PULSE_DEVIEE:
        if (compteurAiguille[aiguille] < dureeImpulsion) {
          // on reste dans PULSE_DEVIEE pendant dureeImpulsion ticks
          compteurAiguille[aiguille]++;
        }
        else {
          // transition vers l'état DEVIEE, on coupe le pulse
          digitalWrite(pinDeviee[aiguille], LOW);
          etatAiguille[aiguille] = DEVIEE;
        }
        break;
      case PULSE_DROITE:
        if (compteurAiguille[aiguille] < dureeImpulsion) {
          // on reste dans PULSE_DROITE pendant dureeImpulsion ticks
          compteurAiguille[aiguille]++;
        }
        else {
          // transition vers l'état DROITE, on coupe le pulse
          digitalWrite(pinDroite[aiguille], LOW);
          etatAiguille[aiguille] = DROITE;
        }
        break;
    }
  }        
  
  // attente de 10ms entre 2 analyses du système
  delay(10);  
}

ON TOUCHE AU BUT !

Depuis fin de matinée, les 2N2222 "aiguillage" ont été remplacés par des BD679.

La mise en test (toujours avec mon programme minimum Arduino) a mis en évidence qu'un pulse de 5/1000 ne suffisait pas pour l'aiguillage. (Il y avait déjà quelques loupés aléatoires sur les relais avec cette valeur)

Après tâtonnements le bon compromis a l'air de se situer à 100/1000. Avec cette valeur AUCUN loupé de réaction, déclenchement franc de l'aiguillage et du relais, en revanche aucun bourdonnement intempestif de la bobine.

Bref le bonheur à l'état pur !    

Maintenant il ne reste plus qu'à tester le programme complet !

Retour sur le test dès que ce sera fait.

A bientôt.

Donc ma dureeImpulsion fixée arbitrairement à 10 (x 10ms) = 100/1000 est bonne   

Voilà 30 minutes que deux locomotives tournent en haut le pied sur le programme mini, sans aucun loupé de détection, ni de bascules relais et aiguillage !   

La partie "hard" de l'installation semble donc totalement valide.

Maintenant, je passe au soft !

Prochaines news dès que possible.

VAUBAN38 a écrit:

Depuis fin de matinée, les 2N2222 "aiguillage" ont été remplacés par des BD679.

Ah la bravo, ça fonctionne... Il me semble que je t'avais suggéré des BD679 dans les premiers posts... Ça confirme que les moteurs d'aiguilles à bobines ont besoin d'une "pêche" de courant, donc nécessite un transistor de type "darlington", cad qu'il est composé dans un seul boitier de deux transistors en cascade, pour obtenir une sortie possible de quelques ampères.

En tout cas,   pour cette réalisation, qui montre un super esprit d'équipe... J'ai appris plein de choses, donc merci à tous les contributeurs. 
Cordialement,

Après implantation du code tel quel, essai sur un seul sens de circulation, (le câblage de l'autre n'étant pas encore finalisé)

Essai réalisé avec deux machines : une Startrain 060DA en haut le pied, et une Piko BB66097 tractant 7 wagons (à peut-être un près, le maxi que la gare peut accepter....)

Tout fonctionne à merveille !     

Au passage de la haut le pied, une seule détection est réalisée par l'IR, pour la 66000 en revanche plusieurs détections en série, mais le changement d'état n'intervient bien qu'après passage total du train ! Même la présence d'un wagon à rancher plat, ridelles abaissées est analysée correctement !

Il faut que je finalise maintenant le câblage de l'autre sens de circulation, pour tester la totalité du programme, mais si çà marche pour un sens, il y a toutes les raisons d'être sereins !

Infos à suivre......

 

Comme quoi quand on pose bien le problème et qu'on modélise avec les outils qui vont bien, ça marche !

(ceci dit je suis quand même un peu étonné que le programme fonctionne du premier coup )

jlb a écrit:

 

Comme quoi quand on pose bien le problème et qu'on modélise avec les outils qui vont bien, ça marche !

Tu oublies simplement le principal : Encore faut-il avoir les compétences ou trouver quelqu'un qui les a pour le faire !

Sans ton aide précieuse, je ne serai jamais arrivé à ce résultat !


Un grand merci, pour ta patience et ta pédagogie.

En tout cas çà m'a vraiment donné envie de continuer à "bidouiller" ( même si c'est à un niveau bien plus modeste ) sur l'Arduino !

J'espère que beaucoup d'autres lecteurs de ce forum auront également profité de nos échanges, et goûteront aussi à cet outil, qui se marie si bien avec notre monde miniature !

C'est avec plaisir. N'hésite pas à concevoir aussi des automates pour gérer les automatismes sur ton réseau et à écrire le programme correspondant. C'est fait pour ça. Tu as visiblement compris les bases et même plus, il faut les utiliser

Avec de petits automates communicants faciles à concevoir et testables individuellement, on peut réaliser des systèmes gérant simultanément beaucoup de fonctions (et sans bazar électroniques en plus de l'Arduino   )

La seule électronique nécessaire à l'extérieur est la puissance.

N'hésite pas à demander aussi

Voilà comme promis les dernières infos.

J'ai terminé aujourd'hui le câblage définitif des 4 quais de la gare cachée, et donc mis en service la totalité des fonctions du programme.

Tout marche nickel !!!       
Les 4 quais sont gérés en simultané sans aucun loupé.

Il ne me reste plus qu'à trouver la solution pour qu'en fin d'utilisation du circuit et avant de redresser le circuit à la verticale dans son caisson, je puisse "forcer" la sortie des deux trains qui seront stockés en gare, sinon....     .

Je pensais à un bouton poussoir permettant cette opération. Reste à l'incorporer judicieusement !

Bonsoir,

Tu peux tout à fait faire ça avec 1 poussoir. Il faut modifier l'automate de détection de train.

On peut voir ça demain

Jicébé a écrit:

Je suis prêt à prêter un grand sac-poubelle !

Un tube de glue serait plus utile !! 

jlb a écrit:

Bonsoir,

Tu peux tout à fait faire ça avec 1 poussoir. Il faut modifier l'automate de détection de train.

On peut voir ça demain

Bonjour,

J'avais imaginé le principe suivant :

- L'automate "sait" quelles sont les positions des deux aiguilles et donc où se situent le dernier train entré dans chaque sens.

- L'impulsion donnée par le poussoir vient "simuler" le passage d'un train devant les deux IR inverses aux positions et donner les ordres de bascules, en libérant ainsi les deux trains "prisonniers".....

Reste à traduire ce principe en langage Arduino et l'incorporer dans le programme, sans y mettre le bazar !!!!  

Avant de modifier le code, il faut d'abord formaliser un peu le problème.

Pour l'instant on a 3 automates qui servent à commander deux gares qui partagent une paire d'aiguille (ce que j'ai appelé une gare c'est une voie ou un quai) : 1 automate par gare et 1 automate pour la paire d'aiguille. Ce système est en deux exemplaires indépendants.

Lorsque les deux automates des gares sont dans l'état ATTENTE, l'une des gares est occupée et l'autre non (c'est pas tout à fait vrai, voir plus loin le problème de sécurisation). On sait celle qui est occupée en consultant l'état de l'automate de l'aiguille. Si la gare[0] est occupée alors l'aiguille est DEVIEE. Si la gare[1] est occupée alors l'aiguille est DROITE.

La correspondance est exactement ce qu'il y a dans le tableau de constantes commandeDeGareAAiguille

Donc en ajoutant à partir de l'état ATTENTE une transition qui est prise si le poussoir est enfoncé et si etatAiguille[gare / 2] == commandeDeGareAAiguille[gare], qui a comme action le changement de la position d'aiguille, ce qui débloque le train, ça fonctionnera.

Attention. Ce n'est pas sécurisé. En effet, si le bouton est pressé alors que l'une des gares est occupée et qu'un train est en train de franchir l'aiguille pour entrer dans l'autre gare, l'aiguille sera changée et le train entrant déraillera. On peut améliorer les choses en modifiant la garde pour ajouter une condition sur le fait que l'autre automate de gare doit être aussi dans l'état ATTENTE.

On peut mettre une table permettant à un automate de gare de regarder l'état de son conjoint :

Code:

const byte conjointDeGare[4] = { 1, 0, 3, 2 };

Donc la garde devient:

Code:

poussoir == ENFONCE && etatAiguille[gare / 2] == commandeDeGareAAiguille[gare] && etatTrain[conjointDeGare[gare]] == ATTENTE

La transition consiste a actionner l'aiguille à l'inverse de ce qui est fait sur la transition ATTELAGE -> ATTENTE. Il faut donc un tableau commandeDeGareAAiguilleArret :

Code:

const byte commandeDeGareAAiguille[4] = {DROITE, DEVIEE, DROITE, DEVIEE};

Il restera le problème du train entrant qui a commencé a franchir l'aiguille d'entrée mais qui n'a pas encore atteint le capteur : les deux automates sont bien dans l'état ATTENTE mais il ne faut pas changer l'aiguille.

Il reste aussi le problème d'un train sortant sur l'autre gare, le changement d'aiguille sera également fatal.

Cette situation ne peut pas être connue du système sans capteur supplémentaire en amont de l'aiguille entrante et en amont de l'aiguille sortante, à la fin de la zone d'arrêt. Comme c'est une procédure d'arrêt, je pense qu'on peut vivre avec

Ok. J'ai parcouru rapidement, mais je manque de temps ce matin pour vraiment "décortiquer".

Je regarde plus précisément ceci à tête reposée !

Deux simples remarques immédiates :
- Pour le risque du train sortant sur l'autre gare, pas de risque de déraillement dans mon cas puisque l'aiguillage de sortie n'est pas piloté (talonnement). En revanche subsiste le risque le risque de télescopage à l'aiguillage si le train sortant est long......

- Mais comme tu le dis en fin de message, on est dans une situation de "fin de service", il appartient à celui qui manipule d'être un minimum attentif, avant de déclencher les hostilités !

Somme toute le plus grand risque à mon sens, sera surtout de relever le plateau en ayant oublié de "vider" la gare ! Et là le sac poubelle de Jicébé prendra toute son utilité