Difficile de faire plus simple : une seule pièce d'habitation et un toit plat.
Dimensions extérieures : environ 45 x 54 x 33 mm.
Quatre ouvertures dont une porte.
... et c'est tout.
Plus modeste, on peut pas.
Les murs ont une épaisseur de 3 mm.
Difficile de faire plus simple : une seule pièce d'habitation et un toit plat.
Dimensions extérieures : environ 45 x 54 x 33 mm.
Quatre ouvertures dont une porte.
... et c'est tout.
Plus modeste, on peut pas.
Les murs ont une épaisseur de 3 mm.
Pour imprimer cette petite maison j'ai choisi du fil PolyWood. C'est un PLA avec du bois qui donne à la pièce un aspect "bois mat" ou "terre sèche". Facile à enduire et à peindre.
Suivant l'imprimante utilisée, il sera nécessaire de réduire au papier de verre les dimensions du toit pour qu'il s'encastre correctement et vienne en appui sur les petites nervures qui ceinturent le bâtiment à l'intérieur des murs.
Pour éviter l'affaissement des linteaux l'impression est paramétrée avec "supports d'impression", c'est à dire que les porte et fenêtres (ben oui, ya qu'une porte ! ) seront remplies d'une sorte de nid d'abeille qui supportera les linteaux au moment de leur impression.
Il faudra ensuite désoperculer toutes les ouvertures pour les débarrasser de ces supports, puis ébavurer correctement.
La maison, avec son toit, et la porte partiellement désoperculée.
Note :
Cette petite maison peut être facilement imprimée à l'échelle "N".
Il suffit, dans CURA by Dagoma, d'utiliser les mêmes fichiers ".stl" et d'appliquer le coefficient de réduction 0,54. (Hé oui ! Pas besoin de redessiner).
L'impression prendra 20 minutes et 4 grammes de PLA pour un coût matière de l'ordre de 0,20€ !
Si l'échelle 1:43 vous tente, il suffit d'appliquer un coefficient x2 dans CURA.
Il faudra 5 heures d'impression et 73 grammes de PLA (moins de 4€).
C'est encore jouable.
Ah ! petite remarque : le bâtiment est marqué "HUGO 2017" à l'intérieur.
Mon petit fils voulait que "son œuvre" soit signée ! (c'est la seule chose que j'ai faite sur ce modèle).
Téléchargements :
Petite maison en adobe
Un de mes petits fils voulait absolument dessiner et imprimer une maison en 3D.
J'ai orienté son choix vers un modèle simple : une petite maison de paysan modeste de la région de Santa Fe, en adobe, qui va me servir sur mon réseau. Tant qu'à faire...
PONT TOURNANT SIMPLE
avec un
MOTEUR PAS à PAS
Créé : 10/2022 ; Mis à jour : 21/11/2022
L'objectif est d'utiliser ARDUBLOCKLY ‒ et uniquement ARDUBLOCKLY ‒ pour écrire un programme de commande de pont tournant.
ARDUBLOCKLY, dans la section «Motors», dispose bien d'un bloc pour piloter un moteur pas-à-pas.
Ce bloc ne permet pas de commander un moteur à 4 fils.
⇒ nous ne l'utiliserons pas.
Le choix va donc se porter sur un moteur à 4 fils et un driver associé qui n'a pas besoin d'une bibliothèque spécifique.
Pour ce qui concerne la partie électronique :
-
x1 ARDUINO UNO (ou éventuellement ARDUINO NANO) ;
-
x1 moteur pas-à-pas 28BYJ-48 ;
-
x1 driver POLOLU A4988
Driver Pololu A4988
Caractéristiques
-
Faible sortie RDS (On)
-
Détection/sélection automatique du mode de décroissance du courant
-
Mélange avec les modes de décroissance de courant lent
-
Rectification synchrone pour une faible dissipation de puissance
-
Interne UVLO
-
Croix de protection contre les surintensités
-
Alimentation logique compatible 3.3 et 5 V
-
Arrêt thermique circuits
-
Protection contre les fuites à la terre
-
Protection contre les courts-circuits de charge
-
Cinq modes en option: complet, 1/2, 1/4, 1/8 et 1/16
Moteur 28BYJ-48
Spécifications:
Diamètre: 27mm.
Tension: 5V/12V
Angle de pas: 5.625x1/64.
Rapport de réduction: 1/64.
Câble à 5 fils, moteur pas à pas à 4 phases peut être entraîné par la puce uln2003.
Il peut également être connecté en 2 phases à utiliser.
Couleur: Argent
Note :
Grâce à son rapport de réduction, ce moteur procure un couple très important.
Note 2 :
Ce moteur est très bon marché.
On le trouve sur internet à des prix situés entre 0,70 et 1,50 €.
Il est très souvent livré avec le driver ULN 2003.
Ce driver nécessite l'utilisation d'une bibliothèque additionnelle.
L'utilisation d'un micro-contrôleur ARDUINO permet, si on le désire, une gestion très élaborée du fonctionnement du pont.
(un exemple est décrit dans la page suivante : https://www.les-trains-de-hugo-et-vincent.org/pont-tournant)
Le présent projet est plus abordable :
-
à la mise sous tension, le programme réalise l'initialisation de la position du pont en «voie zéro» ;
-
la sélection de la voie de destination se fait tout simplement grâce à un jeu de boutons poussoirs ;
-
un poussoir d'arrêt d'urgence permet de stopper le déplacement en cours ;
-
un poussoir permet de commander le retournement du pont sur 180°, et cela quelle que soit la position en cours.
Le plateau tournant, en bois, a un diamètre d'environ 280mm.
Il repose sur 3 roulements encastrés dans le plateau carré du dessous.
Une pièce imprimée en PLA supporte le switch du point zéro.
Le doigt métallique, quand il vient en appui sur le switch, détermine la position «zero» du plateau.
C'est à partir de ce point que sont indexées toutes les voies installées autour du pont.
clic sur les images pour les agrandir
...
Pour les essais, les composants sont montés sur un petit breadboard.
Particularités du schéma ci-dessous :
TINKERCAD propose un jeu de composants limités.
En particulier, le moteur pas-à-pas 28BYJ n'existe pas dans sa bibliothèque.
J'ai donc pris le moteur le plus proche physiquement.
Celui-ci comporte 6 fils, alors que le 28BYJ n'en a que 5 :
⇒ le fil vert du moteur visible sur le dessin, en réalité, n'existe pas.
Les autres fils, eux, sont conformes à ceux du 28BYJ.
Clic sur l'image pour l'agrandir
DÉCLARATIONS CONCERNANT LES CONNEXIONS AU DRIVER POLOLU
Dans «Arduino run first» on déclare les sorties reliées au driver Pololu :
-
pin 8 ⇒ commande du sens de rotation ;
-
pin 9 ⇒ impulsions pour la rotation ;
-
pin 13 ⇒ activation du driver. Cette entrée sera maintenue en permanence à l'tat «LOW».
Difficile de faire plus simple en terme de commande d'un moteur pas-à-pas.
DÉCLARATIONS DE CONFORT
Le sens de rotation du moteur est déterminé par l'état «LOW» ou «HIGH» de la sortie n°8.
Pas très parlant.
... d'autant que, suivant la façon dont le moteur est installé, le sens se rotation risque d'être inversé.
Or, ce qui nous importe, c'est de commander la rotation dans le sens «Avant» ou «Arriere» de façon intuitive.
Grâce aux déclarations ci-contre
-
«Avant» sera l'équivalent de «LOW» ;
-
«Arriere» sera l'équivalent de «HIGH».
De la même façon, pour ce qui concerne l'état d'un poussoir
-
«LOW» sera l'équivalent de «ON» ;
-
«HIGH» sera l'équivalent de «OFF»...
(... si bien sûr les poussoirs réalisent un contact vers le zéro volt.)
VARIABLES NÉCESSAIRES POUR COMMANDER LE MOTEUR
Pour commander le moteur le programme communiquera au driver Pololu les informations suivantes :
-
le sens de rotation ;
-
le nombre de pas ;
-
la durée des impulsions (qui, en fait, détermine la vitesse de rotation).
La variable «Compteur» est utilisée dans les boucles «Count with...» lors des commandes de déplacements. C'est théoriquement une variable locale, mais ARDUBLOCKLY nous oblige à la déclarer dans le setup (Arduino run first).
POSITION DU PONT
À la fin de chaque déplacement, le programme a besoin de connaître la position du pont : le numéro du pas correspondant à cette position est stocké dans «Position_du_pont».
«Arduino run first» COMPLET (pour l'instant)
Les valeurs affectées aux 7 premières instructions sont impératives et ne varient pas pendant le déroulement du programme.
Les 5 variables suivantes vont être modifiées pendant le déroulement du programme.
Ceci n'empêche pas de leur affecter une valeur dans «Arduino run first».
C'est la première action que le programme doit accomplir.
En effet, lorsqu'on coupe l'alimentation électrique à la fin d'une séance, la position du pont est quelconque.
Lors de la mise en route suivante, pour que la suite des opérations se déroule correctement, il est donc indispensable d'amener le pont dans une position connue, à partir de laquelle seront calculés les déplacements.
C'est le calage du pont «en voie zero».
Cette action sera appelée une seule fois au moment
de la mise sous tension.
On va donc créer une fonction personnelle «Calage_du_zero»
qui sera installée dans «Arduino run first»,
à la suite des déclarations des variables :
FONCTION PERSONNELLE «Calage_du_zero»
Le plateau rotatif du pont est équipé d'un doigt métallique.
Lorsque ce doigt vient en contact (en marche arrière) avec un switch fixe, le pont s'arrête.
⇒ cette position est la position «zero» à partir de laquelle seront déterminée les positions des voies.
Comment se déroule le calage du zero ?
Comme l'ARDUINO ne connaît pas la position exacte du pont lors de la mise sous tension, le pont doit d'abord accomplir 3 mouvements :
-
dégager en marche avant de quelques centaines de pas, au cas où le doigt serait déjà en contact avec le switch ;
-
revenir vers le switch jusqu'à ce que le contact se fasse ⇒ la position «zéro» est atteinte ;
-
partir en marche avant vers la «voie zéro» et s'arrêter ⇒ ainsi on peut visuellement contrôler que le pont est physiquement correctement calé.
La fonction «Calage_du_zero» sera donc composée de 3 fonctions personnelles :
-
Degager
-
Retour_vers_switch
-
Voie_zero
FONCTION PERSONNELLE «Degager»
Trois instructions pour paramétrer le déplacement.
«Duree_d_impulsion = 1» correspond à l'impulsion la plus courte que supportent le driver et le moteur.
C'est aussi la vitesse la plus rapide.
«Degager» appelle ensuite la fonction personnelle «Rotation» qui va réaliser le déplacement.
FONCTION PERSONNELLE «Rotation»
Cette fonction envoie au driver les commandes pour faire tourner le moteur dans le bon sens, et du nombre de pas voulu.
Elle sera appelée par d'autres fonctions personnelles. Pour cette raison, elle doit être universelle, c'est à dire qu'elle doit fonctionner dans les différentes circonstances de déplacement.
En fait cette fonction est extrêmement simple :
-
envoi du sens de rotation sur la pin 8 ;
-
envoi sur la pin 9 d'une succession de créneaux «HIGH»/«LOW» calibrés par «Duree_d_impulsion»
Le nombre de créneaux souhaités est porté par la variable «Nombre_de_pas»
Autre version possible
La boucle «count with [compteur] ...» est remplacée par la boucle «repeat [Nombre de pas]...»
La boucle «repeat...» n'utilise pas de compteur auxiliaire.
Son écriture est plus simple.
En fait, c'est une version simplifiée de «count with...».
«count with...» offre plus de possibilités de paramétrage dont nous n'avons pas forcément besoin dans le cas présent.
FONCTION PERSONNELLE «Retour_vers_switch»
Cette fois, la fonction ne transmet pas un nombre de pas à la fonction «Rotation».
Le sens de rotation est programmé sur «Arriere»
La boucle «repeat until...» fait tourner le pont en marche arrière, 1 pas à la fois, jusqu'à ce que (until) le switch connecté sur l'entrée n° 3 passe à l'état «ON».
Note : on a vu plus haut que l'état «ON», pour faciliter la lisibilité du programme, a été défini comme étant l'état «LOW»
La fonction «Rotation» est appelée à chaque passage dans la boucle «repeat until...».
Ainsi, quand le doigt métallique du plateau atteindra le switch, la position «zero» sera exacte à 1 pas près.
La temporisation de 4 millisecondes sert à ralentir le mouvement.
Elle n'est pas absolument indispensable.
FONCTION PERSONNELLE «Voie_zero»
Rien de particulier :
-
le sens de rotation est fixé en marche avant ;
-
la durée d'impulsion est calibrée à «1» (la plus rapide possible dans cette application) ;
-
«1000» est le nombre de pas à parcourir pour atteindre la position de la voie zéro (dans la réalité, cette valeur sera ajustée en fonction de la véritable position physique de la voie zéro) ;
-
appel de la fonction «Rotation».
Une particularité importante toutefois :
Lorsque la rotation est terminée, l'instruction
«set Position_du_pont to 1000» indique au programme que le pont est arrêté au pas n° 1000.
Ouais ! T'as pas trouvé plus intelligent ?
Quelle impatience !
OK.
La voie zéro est une voie comme les autres.
On lui affecte donc une variable : «Index_voie_0» qui contient sa position absolue par rapport au point zéro.
(en fait il s'agit plutôt d'une constante, mais ARDUBLOCKLY ne nous offre pas cette possibilité de déclaration).
Cette variable doit être déclarée et paramétrée dans «Arduino run first».
Ainsi, au lieu d'utiliser une valeur fixe (1000 par exemple) on affecte aux deux variables la valeur contenue dans «Index_voie_0».
Le pont est maintenant en face de la voie n° 0 et sa position «Index_voie_0» est connue.
Il s'agit maintenant de commander le déplacement du pont vers une voie déterminée.
COMPLÉTER «Arduino run first»
Pour déplacer le pont vers une voie, on a besoin de connaître la position absolue de la voie de destination par rapport au «point zéro».
On l'appellera «Index_voie_X».
«Index_voie_X» contiendra le nombre de pas qui séparent cette voie du «point zéro».
La détermination de l'index de chaque voie est un exercice un peu long, qui se fera par tâtonnements.
On peut envisager que le programme comporte une partie qui permet une détermination plus aisée des index de voies, mais c'est plus complexe que la commande du pont elle-même.
Ajouter autant de variables «Index_voie_...» qu'il y a de voies autour du pont.
Note :
Ici, l'index de la voie zéro a été fixé arbitrairement à 2000.
Ajouter la variable «Destination» dans laquelle sera stocké l'index de la voie choisie.
La variable «Destination» sera utilisée pour calculer le déplacement relatif que doit effectuer le pont pour aller de la voie «X» à la voie «Y».
Le résultat calculé de ce déplacement relatif sera versé dans la variable «Valeur_du_deplacement».
FONCTION PERSONNELLE «Choisir_la voie»
Cette fonction teste successivement lequel des switchs de sélection de voie est appuyé.
Si aucun switch n'est appuyé, «Choisir_la_voie» ne fait rien et «Arduino loop forever» tourne sans rien faire.
Si un switch est appuyé, c'est-à-dire «ON», alors :
-
la variable «Destination» reçoit la valeur de «Index_voie_X» de la voie sélectionnée ;
-
«Choisir la voie» appelle la fonction personnelle «Calcul_du_deplacement».
Note :
Le 4e test est grisé (inhibé).
C'est volontaire, pour indiquer que la liste des destinations peut être étendue à un plus grand nombre de voies, suivant les besoins de chacun.
(la limite est le nombre d'entrées/sorties disponibles sur l'ARDUINO UNO).
L'appel à la fonction personnelle «Choisir_la_voie» est installé dans «Arduino loop forever».
Le corps principal du programme est donc réduit à ce simple appel à la fonction «Choisir_la_voie» !
FONCTION PERSONNELLE «Calcul_du_deplacement»
Ah ! Là on va entrer dans le dur...
Meuh non !
Que des additions et des soustractions.
Le nombre de pas à effectuer, transmis par le programme au driver, doit être un nombre POSITIF.
Note :
Les déplacements d'une voie vers l'autre sont des déplacements relatifs :
Le nombre de pas à effectuer est la différence entre l'index de la voie d'arrivée et l'index de la voie de départ.
Par exemple, pour aller de la voie n°2 à la voie n°4, cette différence (appelée «Valeur_du_deplacement») est POSITIVE.
Mais, pour aller de la voie n°4 à la voie n°2, elle est est NÉGATIVE.
La fonction «Calcul_du_deplacement» a précisément pour rôle de rendre positive la valeur du nombre de pas issue du calcul (Destination ‒ Position_du_pont).
Si «Valeur_du_deplacement» est positive, alors :
-
le sens de rotation est réglé sur «Avant» ;
-
la durée d'impulsion est fixée ;
-
le «Nombre_de_pas» (... à effectuer) est égal à «Valeur_du_deplacement» ;
-
le pont se met en rotation.
Si «Valeur_du_deplacement» est négative, alors :
-
le sens de rotation est réglé sur «Arriere» ;
-
la durée d'impulsion est fixée ;
-
le «Nombre_de_pas» (... à effectuer) est égal à « ‒ Valeur_du_deplacement»
(moins Valeur_du_deplacement) ; -
le pont se met en rotation.
À la suite de l'un ou l'autre traitement, l'instruction «set Position_du_pont to Destination» affecte à la variable «Position_du_pont» sa nouvelle valeur.
Ainsi, à chaque fin de déplacement, la nouvelle position du pont est connue du programme.
Note :
‒ la position de chaque voie est fixée (dans Arduino run first) en valeur absolue par rapport au «point zéro».
‒ les déplacements, eux, sont calculés en valeur relative à partir de la position «en cours» du pont, c'est-à-dire à partir de «Position_du_pont».
T'aurais pas oublié un truc ?
Oui.
Le cas où Valeur_du_deplacement = 0
En fait, le cas Valeur_du_deplacement = 0 ne se produit que si on ré-appuie sur le même bouton de destination.
Ce cas est bel et bien traité dans la fonction «Calcul_du_deplacement».
Eh oui.
Si Valeur_du_deplacement n'est ni positive ni négative, elle ne peut être que égale à zéro.
Dans ce cas là, aucun des deux tests n'est vrai.
⇒ on saute directement à l'instruction «set Position_du_pont to Destination», qui ne fait que confirmer que la position du pont est la destination actuelle.
1 à 0 pour moi...
Oui.
Bon. Ça va !
Le programme ARDUBLOCKLY est en téléchargement ICI ⇒
L'arrêt d'urgence est destiné à bloquer brutalement la rotation du moteur en cas en cas d'ennui mécanique : loco mal engagée sur le pont, par exemple. On évite ainsi un risque d'endommager le matériel. Aussi bien la loco que le pont lui-même.
Tout d'abord on va créer la fonction personnelle «Arret-d-urgence»
(Le switch de commande d'arrêt d'urgence sera connecté entre la broche n°2 et le zéro volt).
Que doit faire la fonction Arret-d-urgence ?
-
tester l'état du switch sur l'entrée n°2 ;
-
si le switch est actionné (contact au zéro volt), alors la rotation est stoppée et ne peut pas redémarrer.
Pour reprendre le cours normal des opérations, après avoir supprimé le défaut, il faut éteindre et rallumer le pont tournant, c'est-à-dire réinitialiser le programme.
Comment arrêter la rotation et empêcher son redémarrage ?
Rien de plus simple.
-
l'instruction «if...» teste l'état du switch sur l'entrée n°2 ;
-
si le résultat du test est «vrai», alors on active la boucle «repeat while 1 = 1» ;
-
sinon l'instruction «if...» est sans effet, et par conséquent la fonction «Arret_d_urgence» aussi :
⇒ retour vers la fonction «Rotation» qui continue d'envoyer les impulsions au driver POLOLU.
Elle n'est pas un peu bizarre ton instruction «repeat while 1 = 1» ?
T'énerve pas.
J'explique...
«repeat while 1 = 1» signifie «répète ce qui suit tant que 1 = 1»
Il est évident que «1» sera toujours égal à «1».
Or l'intérieur de la boucle ne contient aucune instruction.
⇒ la boucle «repeat while...» va donc tourner indéfiniment sans rien faire, puisque la condition «1 = 1» sera toujours vérifiée.
Le pont restera inerte, sans possibilité d'appliquer une commande de sélection de voie.
Astucieux, non ?
Oui.
Mais c'est un peu bête
cette boucle vide...
Au lieu de «ne rien faire» la boucle «repeat while...» peut être mise à profit pour faire clignoter une LED, témoin que l'arrêt d'urgence a été activé.
Où fait-on appel à la fonction Arret-d-urgence ?
... dans la fonction «Rotation», à l'intérieur de la boucle qui génère les impulsions envoyées au driver POLOLU.
⇒ après chaque envoi d'une impulsion, la fonction «Arret-d-urgence» teste l'état du contact.
Si le contact est inactif, la boucle peut continuer à envoyer les impulsions.
Autre version possible
Au lieu d'utiliser la boucle «repeat while 1 = 1» on utilise l'instruction «wait forever» (attend indéfiniment).
En langage C++, cette instruction s'écrit :
« if (digitalRead(2) == ON) { while(true) ; } »
«while(true)» signifie «tant que c'est vrai» qui est l'équivalent parfait de «tant que 1 = 1».
Le seul défaut de cette instruction ‒ dans le cas présent ‒ est qu'elle ne permet pas d'ajouter du code pour faire clignoter le témoin d'arrêt d'urgence.
Le programme ARDUBLOCKLY dans sa version actuelle est en téléchargement ICI ⇒
Cet inventaire devrait être fait au début de l'élaboration du projet.
Il permet de déterminer si le projet utilise une carte UNO, ou une carte MEGA.
C'est une aide au câblage.
Cependant, le projet actuel est simple, et dans la mesure où il a été construit pas à pas, il n'est pas trop tard de faire cet inventaire maintenant.
0
1
2
3
4
5
6
7
8
9
10
(ne pas utiliser, si possible)
(ne pas utiliser, si possible)
switch arrêt d'urgence
switch de calage de la position initiale du pont
switch voie 0
switch voie 1
switch voie 2
switch voie 3
sortie de la commande du sens de rotation
sortie des impulsions de rotation
switch voie 4
11
12
13
A0
A1
A2
A3
A4
A5
switch voie 5
témoin d'arrêt d'urgence
activation du driver POLOLU
(disponible)
(disponible)
(disponible)
(disponible)
(disponible)
(disponible)
Au total, ARDUINO UNO dispose de 20 entrées/sorties (0 à 13 = 14 e/s, plus A0 à A5 = 6 e/s).
-
il est préférable de réserver «0» et «1» à la communication entre deux ARDUINO ;
-
dans le mode utilisé par le présent programme, le driver POLOLU utilise 3 sorties pour fonctionner (8 ; 9 ; 13) ;
-
le switch d'arrêt d'urgence occupe une entrée (pin 2) ;
-
le switch de calage de la position initiale du pont occupe une entrée (pin 3) ;
Il reste en pratique (20 ‒ 6) = 14 entrées/sorties disponibles pour sélectionner des voies.
Suivant le projet envisagé, l'exploitation du pont mobilisera en plus quelques entrées/sorties supplémentaires :
-
sortie pour commander un relais d'inversion de la polarisation de la voie du pont (pin A5) ;
-
switch pour commander le retournement du pont (sélection de la voie fictive) (pin A4) ;
-
sortie pour un témoin (LED) qui indique que l'arrêt d'urgence a été activé (pin12) ;
-
sortie pour un témoin (LED) qui indique que le pont est en mouvement (pin A3).
... ce qui ramène à 10 le nombre de voies possibles (12 si on utilise quand même les broches «0» et «1» ).
Faire un demi-tour,
ce n'est pas très compliqué tout de même ?
Compliqué, non.
Mais pas si simple.
Le schéma ci-dessous va nous aider à comprendre :
-
les voies sont représentées par des flèches noires dont le sens indique leur polarité électrique ;
-
le point rouge sur la voie du pont est le point de référence de sa position ;
-
en rouge est figurée une «voie fictive de retournement».
Cette voie est physiquement inexistante. Elle est située pile en face de la voie «0».
L'intérêt de cette «voie fictive» est que, comme toutes les autres voies de garage, elle a un index défini et déclaré dans le setup du programme.
Lorsqu'on choisira de retourner une machine, le programme orientera le pont (point rouge du schéma) vers cette voie fictive en utilisant cet index.
Peu importe que le «+» soit sur le rail de droite ou le rail de gauche.
Peu importe qu'on soit en analogique ou en digital.
Peu importe que la machine roule en marche avant ou en marche arrière.
Ce qui est important c'est que, lorsqu'une loco entre sur le pont ou en sort, les flèches soient dans le même sens, c'est à dire que les deux voies aient la même polarité électrique.
En fait, toutes les voies de garage et la voie d'entrée sont toujours de même polarité.
Seule la voie du pont est susceptible de changer de polarité.
Scénario pour retourner une machine à vapeur :
-
le pont est dans la position représentée ci-dessus.
Son extrémité de référence (point rouge) est en face de la voie «0».
Les deux flèches sont dans le même sens ⇒ polarités identiques des deux voies ⇒ la loco entre sur le pont ;
-
le pont est mis en rotation vers la «voie fictive», comme si cette voie était une voie de garage quelconque.
⇒ l'extrémité de référence du pont (point rouge) se trouve finalement en face de la «voie fictive» ;
⇒ or, les deux pointes de flèche (du pont et de la voie «0») se font face : les polarités de ces deux voies sont donc en opposition ;
⇒ il y a donc nécessité d'inverser la polarité du pont pour la mettre en conformité avec celle de la voie «0».
‒ C'est le seul cas qui nécessite une inversion de polarité du pont.
‒ Je le prouve...
‒ Euh !
T'es sûr ?
Scénario pour entrer une machine à vapeur sur la voie 1 :
-
le pont est dans la position représentée ci-dessus.
-
le pont est mis en rotation vers la voie «1» ;
⇒ l'extrémité de référence du pont (point rouge) se trouve finalement en face de la voie «1» ;
⇒ les deux pointes de flèche (du pont et de la voie «1») sont alignées : les polarités de ces deux voies sont donc identiques ;
⇒ il y a donc pas nécessité d'inverser la polarité du pont : la loco peut reculer sur la voie 1.
VERSION ULTRA SIMPLE :
RETOURNEMENT SEUL
(180°)
Créé : 21/11/2022 ; Mis à jour :
