ModelleisenbahN

Accueil > La technologie > Arduino > Manœuvre des aiguilles avec des servo-moteurs > Plusieurs boutons poussoir sur une entrée analogique

Manœuvre des aiguilles en analogique avec des servo-moteurs

Plusieurs boutons poussoir sur une entrée analogique

publié par Jean-Luc, le samedi 16 novembre 2013

Tags aiguille - arduino - servo

Dans « Commande du servo-moteur par bouton poussoir », nous avons vu comment connecter un bouton poussoir à une entrée analogique. Dans celui-ci nous allons voir comment en connecter plusieurs et lire lequel est enfoncé.

Cette idée de connecter plusieurs poussoirs sur une entrée analogique n’est pas nouvelle. Une Application Note de Freescale existe et l’idée m’a été soufflée par Marc-Henri que je remercie au passage.

Marc-Henri vient de publier un article sur son blog qui décrit précisément le calcul des résistances ainsi qu’une feuille de calcul (format Excel) le mettant en œuvre pour un nombre quelconque de poussoirs

Principe de fonctionnement

Avec un seul poussoir, nous avons vu que l’entrée analogique de l’Arduino était tirée à la masse via une résistance de 10kΩ. L’appui sur le poussoir amenait cette entrée à 5V. Pour la suite, on va inverser la connexion. L’entrée analogique esr tirée à +5V et l’appui sur le poussoir amène cette entrée à la masse. En effet, avec plusieurs poussoirs, cette façon de faire est plus commode car, sur le réseau, la masse est distribuée partout alors que ce n’est pas le cas pour le +5V.

PNG - 44.1 ko
Connexion d’un poussoir à l’entrée analogique de l’Arduino Uno, état de repos à +5V

Imaginons maintenant que nous ajoutions un second poussoir en parallèle du premier et qu’il soit connecté entre l’entrée analogique de l’Arduino et la masse via une résistance, également de 10kΩ, comme ceci.

PNG - 47.9 ko
Connexion de deux poussoirs à une entrée analogique

Lorsque B0 est pressé, nous avons le même comportement, l’entrée analogique est à 0V. Lorsque B1 est pressé, les deux résistances sont en série entre 5V et 0V et l’entrée analogique est à la tension qui existe entre les deux résistances. On voit qu’il s’agit d’un diviseur de tension, et donc l’entrée analogique est à 2,5V. Evidemment, on ne peut pas presser 2 poussoirs en même temps, l’Arduino ne verra que le poussoir de rang le plus bas.

On peut continuer à ajouter des poussoirs en parallèle avec la résistance adéquate pour que le diviseur de tension donne une tension précise pour chaque poussoir. Pour nos 8 boutons-poussoir, nous allons procéder de cette manière.

PNG - 40.8 ko
Connexion de 8 poussoirs à une entrée analogique

Avec 8 poussoirs, il faut diviser les 1024 valeurs possibles en 8 intervalles de 1024 ÷ 8 = 128 valeurs. Plus on ajoute des poussoirs et plus cet intervalle devient petit. Plus cet intervalle devient petit et plus il est nécessaire d’avoir des résistances précises. Or, les résistances standards ont des valeurs déterminées et sont précises à 5%. Si les intervalles sont trop petits, il devient impossible de distinguer deux valeurs voisines de façon fiable. Cela limite le nombre de poussoirs que l’on peut connecter mais 8 poussoirs ne devraient pas poser de problème.

PNG - 36.2 ko

Sur la figure précédente, la plage de valeurs analogiques a été découpée en 8 intervalles. En (a) le poussoir pressé, en (b) la tension correspondante, en (c) la valeur numérique, en (d) cette même valeur numérique en binaire. Il faut donc déterminer les résistances R1 à R7 de manière à obtenir plus ou moins la tension voulue. On va voir que ça se fait assez bien.

Une fois une valeur analogique numérisée, il faut déterminer par programme de quel poussoir il s’agit. On peut le faire par une succession de if ... else ... en testant la valeur lue par rapport au milieu des intervalles : entre 0 et 63, aucun poussoir n’est pressé, entre 63 et 191, B0 est pressé, entre 192 et 319, B1 est pressé, etc. Mais c’est un peu long. On peut écrire cela de manière plus concise, un programmeur est un fainéant, moins il écrit de code, mieux il se porte.

Pour cela, nous allons diviser la valeur lue par la taille de l’intervalle (128).
Il s’agit évidemment d’une division entière, le résultat donnerait le numéro du poussoir pressé, il s’agit des 3 bits de poids fort dans la colonne (d), ceux qui sont séparés des autres. Malheureusement, on peut voir que ce résultat change au voisinage de la valeur lue. Par exemple au voisinage de 127, le résultat peut être 0 ou 1 et au voisinage de 255, le résultat peut être 1 ou 2. Par conséquent on peut confondre les deux poussoirs !

Pour malgré tout procéder de cette manière, il suffit de décaler l’intervalle. En ajoutant la moitié de la taille de l’intervalle à la valeur lue, 64 donc, le résultat donné pas la division entière est directement le numéro du poussoir (de 0 à 7), ou bien 8 si aucun poussoir n’est pressé, et ce numéro est stable et centré au voisinage des valeurs lues, comme montré à la colonne (d). La détermination du poussoir pressé se fait alors en une ligne de code.

  1. int numPoussoir = (analogRead(pinPoussoirs) + 64) / 128;

Cette concision ne peut que réjouir le programmeur ^_^

Immunité au bruit et détermination des résistances

Les essais avec un seul poussoir ont employé une résistance de 10kΩ traversée par une courant de 0,5mA quand le poussoir est pressé. Avec de longs fils entre les poussoirs et l’Arduino, le bruit électrique dû aux ondes électromagnétiques qui nous environnent peut être important. Il est préférable d’utiliser des résistances de plus faible valeur afin que le courant circulant dans le circuit quand un poussoir est pressé soit plus élevé et que le bruit puisse être absorbé par l’alimentation. Nous allons donc choisir un courant maximum d’environ 15mA, soit une résistance de 330Ω à la place de la résistance de 10kΩ utilisée jusqu’à présent.

Il faut maintenant déterminer les valeurs des résistances R1 à R7 pour obtenir les tensions que nous avons déterminées. Les diviseurs de tension pour chacun des poussoirs sont les suivants.

PNG - 21.4 ko
Les diviseurs de tension pour chacun des poussoirs.

Par calcul on détermine les valeurs des résistances pour chaque poussoir. La colonne Résistance donne la résistance qui serait nécessaire, la colonne Résistance approchée donne la valeur standard employée et la colonne Tension approchée donne la tension effectivement obtenue en supposant évidemment que la résistance est juste.

  Tension Résistance Résistance approchée Tension approchée Erreur
R1 0,625V 47,14Ω 47Ω 0,634V 0,04%
R2 1,25V 62,85Ω 62Ω 1,27V 0,23%
R3 1,875V 88Ω 82Ω 1,89V 1,34%
R4 2,5V 132Ω 130Ω 2,53V 1,38%
R5 3,125V 220Ω 220Ω 3,17V 1,03%
R6 3,75V 440Ω 430Ω 3,76V 1,46%
R7 4,375V 1320Ω 1300Ω 4,377V 1,50%

Le retour du rebond

Il ne s’agit pas tout à fait d’un rebond mais il va falloir prendre en compte ce que l’on appelle une transitoire.

Quand l’un des poussoirs est pressé, l’entrée analogique passe de 5V à la tension correspondante telle qu’elle a été réglée par les résistances. Mais elle ne le fait pas instantanément. Cela prend un certain temps.

Imaginons maintenant que le convertisseur analogique-numérique de l’Arduino capture la tension alors que celle-ci est en train de descendre. Le résultat va être que le logiciel croit voir une pression sur un poussoir de rang supérieur à celui véritablement pressé. De même quand le poussoir va être relâché, la capture de la tension peut avoir lieu alors qu’elle est en train de monter et retourner également un numéro de poussoir de rang supérieur. Il faut donc filtrer ces transitoires et n’accepter la valeur brute calculée dans numPoussoir que sous certaines conditions.

Avec un seul poussoir ce phénomène n’existait pas car il n’y avait pas d’autre poussoir.

Pour filtrer les valeurs non voulues, nous allons mettre en œuvre ce que l’on appelle un système séquentiel. On représente ce genre de système par un graphe, appelé automate. Un ovale est un état, une flèche est une transition qui permet de passer d’un état à l’autre. Les textes en vert sont des conditions qui permettent ou empêchent une transition et les textes en rouge des actions qui sont effectuées lors d’une transition. L’ovale à double bordure est l’état initial. La flèche qui vient de nulle part et qui pointe sur l’état initial correspond aux actions d’initialisation.

Voici l’automate de notre système.

PNG - 55 ko
Automate de lecture de l’état des poussoirs
Entre chaque transition, le temps nécessaire à l’exécution de loop(), s’écoule.
Le passage par l’état ENFONCE permet de laisser passer du temps entre la détection de la pression sur un poussoir et la lecture du numéro correspondant. Ce numéro n’est pas réactualisé dans l’état PRESSE, ce qui permet de filtrer les valeurs non désirées lors du relâchement du poussoir.

À partir de l’état initial, NON_PRESSE, qui correspond à aucun poussoir enfoncé, on peut :

  • rester dans cet état (aucun poussoir enfoncé correspond à un numéro de poussoir égal à 8) ;
  • passer dans l’état ENFONCE (l’un des poussoir enfoncé correspond à un numéro de poussoir inférieur à 8).

Une fois dans l’état ENFONCE :

  • soit le poussoir est relâché immédiatement (c’est à dire en quelques millisecondes, il s’agissait d’un rebond ou d’un parasite), le numéro de poussoir est égal à 8 ;
  • soit il est toujours enfoncé, numéro de poussoir inférieur à 8 et on confirme en passant dans l’état PRESSE et en mémorisant dans etatBouton le numéro du poussoir enfoncé.

Dans l’état PRESSE :

  • soit le poussoir est maintenu enfoncé (numPoussoir < 8) et on attend en restant dans l’état PRESSE ;
  • soit le poussoir est relâché (numPoussoir == 8) et on repasse dans l’état NON_PRESSE en remettant etatBouton à -1.

Le passage de l’automate à un programme C est direct. On va avoir besoin d’une variable pour stocker l’état dans lequel se trouve l’automate ainsi que des variables employées par l’automate. Comme il est impossible de détecter plusieurs poussoirs enfoncés, il est inutile d’avoir une variable d’état par poussoir. Une seule variable suffit mais elle a autant d’états que de poussoirs plus une pour représenter le fait qu’aucun poussoir n’est enfoncé.

  1. const byte NON_PRESSE = 0;
  2. const byte ENFONCE = 1;
  3. const byte PRESSE = 2;
  4.  
  5. byte etatAutomate = NON_PRESSE;
  6. int etatPoussoir = -1; /* aucun poussoir n'est pressé au début */
  7.  
  8. const int pinPoussoirs = 0;
  9.  
  10. int lirePoussoirs()
  11. {
  12. int resultat;
  13. int numPoussoir = (analogRead(pinPoussoirs) + 64) / 128;
  14.  
  15. int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */
  16.  
  17. switch (etatAutomate) {
  18. case NON_PRESSE:
  19. if (numPoussoir < 8)
  20. etatAutomate = ENFONCE;
  21. break;
  22. case ENFONCE:
  23. if (numPoussoir < 8) {
  24. etatAutomate = PRESSE;
  25. nouvelEtatPoussoir = numPoussoir;
  26. }
  27. else {
  28. etatAutomate = NON_PRESSE;
  29. }
  30. break;
  31. case PRESSE:
  32. if (numPoussoir == 8) {
  33. etatAutomate = NON_PRESSE;
  34. nouvelEtatPoussoir = -1;
  35. }
  36. break;
  37. }
  38.  
  39. return nouvelEtatPoussoir;
  40. }

Télécharger

Il reste à modifier lireEvenement(...) pour l’adapter à lirePoussoirs(). En effet, en plus de l’information de présence d’événement, il est nécessaire d’obtenir le numéro du poussoir qui a déclenché l’événement. Or une fonction C ne retourne qu’une seule valeur. Il faut donc trouver un moyen pour obtenir la seconde valeur, le numéro du poussoir.

Nous allons employer un argument. En C les arguments sont passés aux fonctions par valeur. C’est à dire que la valeur contenue dans la variable que l’on passe à la fonction est recopiée dans une variable locale de la fonction. Si la fonction change le contenu de cette variable, seule sa copie est changée. Il faut donc employer un autre moyen pour que la fonction puisse modifier la variable qui lui est passée. Ce moyen, ce sont les pointeurs.

Une variable est placée dans la mémoire RAM du micro-contrôleur. On peut voir la RAM comme un tableau de cases. Chaque case a un numéro, on dit une adresse. Il est possible d’obtenir l’adresse d’une variable via l’opérateur &, de définir une variable qui soit un pointeur vers un type, via la notation * et il est possible d’écrire ou de lire dans une variable par l’intermédiaire de son adresse via l’opérateur *. Ainsi :

  1. int *p;

définit un pointeur vers une variable de type int. Ce pointeur est pour l’instant non initialisé, il ne pointe sur rien. Essayer d’accéder à ce qu’il pointe est une erreur.

  1. int a;
  2. int *p = &a;

Télécharger

définit un pointeur p vers une variable de type int qui pointe sur a. &a retourne l’adresse de a.

  1. *p = 3;

met la valeur 3 dans la variable a.

Pour définir la fonction lireEvenement(...) qui retourne un byte et prend pour argument un pointeur vers un int, et qui modifie la variable pointée, on écrira.

  1. byte lireEvenement(int *numPoussoir)
  2. {
  3. byte evenement;
  4. int nouvelEtatPoussoir = lirePoussoirs();
  5.  
  6. if (nouvelEtatPoussoir == etatPoussoir)
  7. evenement = AUCUN_EVENEMENT;
  8. if (nouvelEtatPoussoir >= 0 && etatPoussoir == -1)
  9. evenement = EVENEMENT_PRESSE;
  10. if (nouvelEtatPoussoir == -1 && etatPoussoir >= 0)
  11. evenement = EVENEMENT_RELACHE;
  12.  
  13. etatPoussoir = nouvelEtatPoussoir;
  14. *numPoussoir = etatPoussoir;
  15.  
  16. return evenement;
  17. }

Télécharger

L’argument int *numPoussoir définit numPoussoir qui est un pointeur sur un int. À l’avant dernière ligne de la fonction, l’état du poussoir est écrit dans la variable pointée par numPoussoir, il s’agit de la ligne *numPoussoir = etatPoussoir;

Il faut donc que numPoussoir pointe sur la variable dans laquelle on désire récupérer le numéro de poussoir. Donc, pour appeler cette fonction, on écrira.

  1. int numeroPoussoir;
  2. byte evenement = lireEvenement(&numeroPoussoir);

Télécharger

ce qui a pour effet de passer à la fonction l’adresse, opérateur &, de numeroPoussoir afin d’obtenir la valeur désirée dans cette variable.

Essai du système

La première étape consiste à câbler sur la breadboard les poussoirs est les résistances comme ceci.

PNG - 225.2 ko
Placement des composants sur le breadboard

Voici le programme complet de test du système. Les messages d’appui ou de relâchement des poussoirs sont affichés sur le moniteur série avec le numéro de poussoir enfoncé.

  1. const byte NON_PRESSE = 0;
  2. const byte ENFONCE = 1;
  3. const byte PRESSE = 2;
  4.  
  5. byte etatAutomate = NON_PRESSE;
  6. int etatPoussoir = -1;
  7.  
  8. const byte AUCUN_EVENEMENT = 0;
  9. const byte EVENEMENT_PRESSE = 1;
  10. const byte EVENEMENT_RELACHE = 2;
  11.  
  12. const int pinPoussoirs = 0;
  13.  
  14. int lirePoussoirs()
  15. {
  16. int resultat;
  17. int numPoussoir = (analogRead(pinPoussoirs) + 64) / 128;
  18.  
  19. int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */
  20.  
  21. switch (etatAutomate) {
  22. case NON_PRESSE:
  23. if (numPoussoir < 8)
  24. etatAutomate = ENFONCE;
  25. break;
  26. case ENFONCE:
  27. if (numPoussoir < 8) {
  28. etatAutomate = PRESSE;
  29. nouvelEtatPoussoir = numPoussoir;
  30. }
  31. else {
  32. etatAutomate = NON_PRESSE;
  33. }
  34. break;
  35. case PRESSE:
  36. if (numPoussoir == 8) {
  37. etatAutomate = NON_PRESSE;
  38. nouvelEtatPoussoir = -1;
  39. }
  40. break;
  41. }
  42.  
  43. return nouvelEtatPoussoir;
  44. }
  45.  
  46. /*
  47.  * construction d'un événement en comparant
  48.  * le nouvel état des poussoirs avec l'état précédent.
  49.  */
  50. byte lireEvenement(int *numPoussoir)
  51. {
  52. byte evenement;
  53. int nouvelEtatPoussoir = lirePoussoirs();
  54.  
  55. if (nouvelEtatPoussoir == etatPoussoir)
  56. evenement = AUCUN_EVENEMENT;
  57. if (nouvelEtatPoussoir >= 0 && etatPoussoir == -1)
  58. evenement = EVENEMENT_PRESSE;
  59. if (nouvelEtatPoussoir == -1 && etatPoussoir >= 0)
  60. evenement = EVENEMENT_RELACHE;
  61.  
  62. etatPoussoir = nouvelEtatPoussoir;
  63. *numPoussoir = etatPoussoir;
  64.  
  65. return evenement;
  66. }
  67.  
  68. void setup()
  69. {
  70. Serial.begin(9600);
  71. }
  72.  
  73. void loop()
  74. {
  75. int numPoussoir;
  76. byte evenement = lireEvenement(&numPoussoir);
  77.  
  78. switch (evenement) {
  79. case EVENEMENT_PRESSE:
  80. Serial.print("Presse : ");
  81. Serial.println(numPoussoir);
  82. break;
  83. case EVENEMENT_RELACHE:
  84. Serial.print("Relache : ");
  85. Serial.println(numPoussoir);
  86. break;
  87. }
  88.  
  89. delay(3);
  90. }

Télécharger

Une petite vidéo montrant la mise en œuvre du programme.

Le système de commande à 8 boutons sur une entrée analogique est opérationnel.

Nous avons vu quelques éléments supplémentaires de langage C comme les pointeurs et leur emploi pour retourner plusieurs valeurs à partir d’une fonction. Nous avons vu rapidement les automates et comment les mettre en œuvre avec un switch ... case. La prochaine fois nous ajouterons nos 8 servo-moteurs.

15 Messages

  • Merci. Un grand merci. Je suis un minuscule débutant mais apprécie votre aptitude à présenter clairement des notions complexes tel ce système séquentiel et son automate. Je suis depuis des semaines sur votre contribution mais j’avance. Encore merci.
    J-P G.

    Voir en ligne : Plusieurs boutons poussoirs sur une entrée analogique

    repondre message

  • Plusieurs boutons poussoir sur une entrée analogique 10 octobre 2014 13:00, par pascalou

    Sans la formule nécessaire au calcul des tensions dans un pont de résistance, cet article est inutilisable pour le néophite que je suis...
    Comment adapter ceci à 4 boutons poussoirs sans savoir calculer ces fameuses valeurs de résistances ?
    Mystère....

    repondre message

    • Bonjour,

      le le blog n’ayant pas comme finalité l’électronique, il ne m’a pas semblé nécessaire de développer ce point. De plus, les articles sur le diviseur de tension ne manquent pas sur le web. Une recherche renvoie en première place l’article Wikipedia qui y est consacré.

      Par ailleurs, passer de 8 à 4 boutons est trivial, il suffit de supprimer les boutons ayant des numéros impair et de sommer les résistances 2 à 2 : R1+R2, R3+R4, etc.

      repondre message

      • Plusieurs boutons poussoir sur une entrée analogique 10 octobre 2014 14:26, par pascalou

        Et non ce n’est pas trivial pour le néophyte que je suis et aller de site en site pour glaner des informations nous fait souvent perdre le fil d’une réflexion entamée sur un sujet précis.
        Ce n’est pas un reproche mais une remarque constructive.
        Je persiste à penser qu’il serait judicieux de préciser l’intégralité de la démarche au niveau des calculs, je ne m’en suis pas sorti seul avec les quelques souvenirs que j’avais de la loi d’ohm et j’ai perdu une ou deux heures avant de me lancer dans de nouvelles recherches...

        Merci tout de même pour avoir partagé toutes ces informations sur internet, elles m’ont été très utiles dans ma tentative de dompter un arduino récalcitrant ;-)

        repondre message

    • Plusieurs boutons poussoir sur une entrée analogique 10 octobre 2014 14:16, par pascalou

      J’ai touvé la réponse à ma question en fouinant sur le net alors je partage ma découverte.
      C’est un tableau excel qui permet d’effectuer les calculs automatiquement.

      Voir en ligne : Tableau de calcul de resistances

      repondre message

  • Plusieurs boutons poussoir sur une entrée analogique 28 février 2015 11:46, par Yvon BOTTAU

    Bonjour
    Quelques mois sont passés depuis ma dernière question.
    Mes 25 actionneurs d’aiguillages sont maintenant assemblés. Merci encore pour toutes ces sources d’inspiration très précieuses.
    Je me permets de vous demander un petit éclaircissement sur la valeur d’une résistance sur le clavier 8 boutons :
    Sur le troisième dessin du module ARDUINO avec le schéma 8 boutons, la première résistance reliée au +5V à une valeur de 10kΩ.
    Par la suite vous mentionnez une résistance d’une valeur de 330Ω (voir placement des composants sur le breadboard) en bas de page.
    Mes connaissances en ce domaine étant limitées, je préfère demander confirmation.
    Encore merci
    Yvon - B

    repondre message

    • Plusieurs boutons poussoir sur une entrée analogique 28 février 2015 11:56, par Jean-Luc

      Bonjour Yvon,

      C’est sympa de donner des nouvelles de l’avancement des travaux. L’explication est dans le paragraphe intitulé « Immunité au bruit et détermination des résistances » plus haut dans le texte.

      Je vous signale également un nouveau site que nous avons lancé avec plusieurs autres Arduinistes du ferroviaire :) : LOCODUINO

      Bien cordialement.

      repondre message

  • Plusieurs boutons poussoir sur une entrée analogique 1er avril 00:45, par Bouabid Tawfik

    Le lien du fichier excel est expiré, prière de le charger sur un autre serveur ou bien de me répondre à propos la méthode de calcul des résistance, pour la première résistance application directe du diviseur de tension (simple) mais les autres tensions on peut pas les calculer en utilisant la formule du diviseur tout court. Merci bien

    repondre message

  • Bonjour,

    pour calculer les valeurs des resistances (pour 5 boutons avec des pas de 1 volts) :

    Pas de bouton pressé = 5v
    Bp1 = 0v
    Bp2 = 1v
    Bp3 = 2v
    Bp4 = 3v
    Bp5 = 4v

    Pour obtenir R2 dans un pont diviseur de tension :

    R2 = R1(ve/vs) - R1

    avec ve = tension entrée et vs = tension de sortie

    donc avec r0 = 330 ohms on obtient :

    R1 = R0(5/4)-R0 = 82,5 ohms
    R1+R2 = R0(5/3)-R0 et on soustrait R1 = 137,5 ohms

    etc....

    cordialement.

    Cyril

    repondre message

  • Plusieurs boutons poussoir sur une entrée analogique 5 avril 16:42, par Bouabid Tawfik

    Bonjour , voici le projet de 16 boutons en isis avec le code arduino ; bon j’ai divisé l’intervalle 0 .. 2047 en 16 intervalles équidistante de longueur 128, c’est pourquoi je multiplie la valeur retournée par "analogread" par 2 .
    le calcul des résistances est fait à l’aide de la formule Req=(Vin/V)/(1-(Vin/V)).R
    avec : V : 5v
    Vin la valeur de tension d’entrée à la carte
    _R : 330 ohm
    _Req : R équivalente , à chaque fois on retranche la somme des résistances précedentes
    le lien du projet et code :

    https://drive.google.com/open?id=0B_XaAqFY961JbUVEV0JQVlByX2s

    repondre message

  • Il y a quelque chose que je ne comprends pas ??!!
    Si on met 5 résistances de x Ohms en série (en pratique 220 Ohms mais ce pourrait être une autre valeur pourvu qu’elles soient identiques, il n’y a que l’intensité qui change) on a exactement 1, 2, 3, 4 et 5 Volts entre la masse et les points de jonction des résistances.
    Si on en met 10 le pas est de 0,5 V
    Alors pourquoi tous ces calculs ?
    Si on veut moins de valeurs, on choisi le nombre de points et pour 3 valeurs on peut prendre 1, 2 et 3 Volts et laisser 4 et 5.
    Désolé je ne sais pas comment faire pour laisser un schéma et j’espère avoir été clair...

    repondre message

Répondre à cet article

Les thèmes

Archives

Informations

ModelleisenbahN | publié sous licence Creative Commons by-nc-nd 2.0 fr | généré dynamiquement par SPIP & Blog'n Glop