Pont tournant

Nombre de visites :
4921
PONT TOURNANT 

Comme je suis d'un naturel flemmard, je me suis efforcé de trouver des solutions qui m'évitent les mécanismes compliqués, les câblages envahissants et les mises au point délicates.

Date de création : 24/10/2017

Dernière modification : 14/01/2020

 
 
De nombreux modèles de ponts tournants existent dans le commerce.
Les plus perfectionnés sont livrés avec une électronique complexe qui gère les mouvements, les positionnements et l'alimentation des voies.
 
Quelques exemples glanés sur le net :
Pont Roco.
Pont HELJAN
Pont Fleichmann
On ne peut que constater  les insuffisances :
  • système de positionnement avec une mécanique pas du tout esthétique ni réaliste (ergot + switch) ;
  • pas mal de câblage ;
  • une motorisation « légère » ;
  • un espacement obligatoirement régulier des voies de garage ;
  • schéma électrique et/ou boitiers de commande d'un autre âge.
 
Bref, aucun des produits commerciaux ne me séduisait vraiment.
De plus, mon réseau est de style « USA » et je comptais bien « tourner » mes Big Boy (avec leur tender) sur un pont aux dimensions adéquates.
520 mm de diamètre en HO !
 
Voilà qui m'interdisait de toutes façons l'adaptation d'un pont tournant du commerce.
 
Seule solution : une construction « maison ».
 
Comme je suis d'un naturel flemmard, je me suis efforcé de trouver des solutions qui m'évitent les mécanismes compliqués, les câblages envahissants et les mises au point délicates.
 
J'ai donc établi une liste de souhaits — sorte de cahier des charges — avec « ce que je veux » et « ce que je ne veux pas ».

 
Ce que je veux
  • poser mes voies de garage là où j'en ai besoin, sans être tenu par un espacement angulaire imposé ;
  • commander le pont indépendamment de la commande des locos : quand on joue « à plusieurs », il y a un des joueurs qui est le chef du dépôt et qui s'occupe du pont et des animations du dépôt ;
  • piloter le pont en étant au plus près de l'action ;
  • piloter le pont AUSSI depuis la console (ce qui impose une double commande) ;
  • un système d'entraînement simple, avec un moteur costaud ;
  • un positionnement des voies sûr et précis, sans hystérésis ;
  • la possibilité d'améliorer les fonctionnements sans toucher à la mécanique.
 
Ce que je ne veux pas
  • être coincé devant un écran d'ordinateur qui rassemble toutes les fonctions de commandes du réseau (système DCC) ;
  • un système de détection de la position du pont basé sur des capteurs opto-électroniques (qui obligent à une installation délicate des diodes émettrices et réceptrices et qui entraîne un câblage foisonnant) ;
  • un système de positionnement basé sur des contacts secs qui posent aussi les mêmes problèmes que ci-dessus ;
  • un système d'entraînement basé sur des roues et vis sans fin, avec tous les problèmes de jeu de fonctionnement, donc d'imprécision de positionnement.
 
Note :
Dans tous les articles qui suivent, le terme « télécommande » ne désigne pas un objet matériel, mais l'application ANDROÏD elle même, qui est un objet virtuel hébergé par un ou plusieurs appareils ANDROÏD.
BLE = Bluetooth Low Energy.

SYNOPTIQUE DE LA PARTIE ÉLECTRONIQUE

Capture_6_pont.png
 
 
Appareil ANDROÏD
  • héberge l'application ANDROÏD de télécommande du pont tournant.
 
ARDUINO N°1
  • reçoit et traite les commandes en provenance du clavier (liaison filaire) ;
  • gère l'afficheur ;
  • reçoit  et traite les commandes transmises par le module BLE (Bluetooth Low Energy) en provenance de l'appareil ANDROÏD ;
  • assure la communication avec l'ARDUINO N°2 (liaison TX→Rx) ;
  • actionne le moteur pas à pas ;
  • actionne l'inverseur de polarité ;
  • assure la cohérence de polarité entre la voie du pont et la voie sélectionnée ;
  • envoie à l'ARDUINO N°2 les ordres nécessaires à la commutation du courant de traction dans les voies.
 
ARDUINO N°2
  • reçoit les ordres de commutation du courant de traction des voies de garage et du pont, en provenance de l'ARDUINO N°1
    (liaison Tx→Rx) ;
  • commande le groupe de relais de commutation du courant de traction ;
 
HC-05 (ou HC-06)
  • reçoit les communications BLE en provenance de l'application ANDROÏD et les transmet à l'ARDUINO N°1.
 
Moteur pas-à-pas (il s'agit d'un modèle à 400 pas / tour. Un modèle à 200 pas / tour convient aussi)
  • actionne le plateau d'entraînement du pont avec une précision de positionnement du pont de 0,1 mm ;
  • l'entraînement se fait par une simple courroie crantée du type de celle qu'on utilise sur les
    imprimantes 3D ;
 
Remarques
  • chaque ARDUINO fait donc tourner un programme spécifique ;
  • la filière « clavier + ARDUINO N°1 + écran + ARDUINO N°2 » constitue une chaîne de télécommande autonome ;
  • la filière « appareil ANDROÏD + application ANDROÏD + HC-05 + ARDUINO N°1 et 2 » constitue aussi une chaîne de télécommande autonome ;
  • les deux filières peuvent fonctionner simultanément, c'est à dire que deux opérateurs peuvent intervenir simultanément pour commander le pont tournant, l'un depuis la console, l'autre à partir de l'appareil ANDROÏD.
 
 
Pourquoi 2 ARDUINO ?
Un ARDUINO UNO ou NANO dispose de 18 entrées-sorties.
  • la gestion du clavier en requiert 7 ;
  • celle de l'afficheur en utilise 2 ;
  • la liaison Tx→Rx en prend 1 ;
  • les contacts de calage du point zéro du pont tournant : 2
  • le relais d'inversion de polarité et commutation de la voie du pont : 1 ;
  • la commande du driver du moteur pas-à-pas  : 4
  • la commande des relais de commutation des voies : 17 ( en fait on verra dans l'article « 06-Sketch ARDUINO » que 9 relais peuvent suffire) ;
     
... ce qui fait un total de 34 entrées-sorties au maximum et 26 au minimum.
L'ARDUINO N°2 ne s'occupe donc QUE de la commutation des voies, et l'ARDUINO N°1 s'occupe des 17 autres entrées-sorties.
Note :
J'aurais pu utiliser une seule carte MEGA, mais cette dernière coûte nettement plus cher que 2 UNO, et avec 2 cartes UNO on a « un peu plus d'air » pour les différents câblages.
 
 
Caractéristiques générales de la partie mécanique du pont tournant
  • 17 voies de garage ou d'entrée/sortie irrégulièrement réparties sur la périphérie ;
  • diamètre du pont 520 mm ;
  • diamètre du plateau d'entraînement (sous la table) : 480 mm ;
  • entraînement par courroie crantée ;
  • axe vertical d'entraînement du pont : tube creux de diamètre 10 mm, monté sur 2 paliers à billes ;
  • précision de positionnement du pont en face des voies : environ 0,1 mm ce qui correspond à 1 pas du moteur p-à-p ;
  • pas d'hystérésis de position suivant qu'on tourne à gauche ou à droite ;
 
Caractéristiques générales de la partie électronique
  • calage automatique du « point zéro » du pont à chaque mise sous tension ;
  • calage à la demande du « point zéro » (utile quand on est intervenu sur la partie mécanique du pont) ;
  • démarrage et arrêt progressif des mouvements du pont ;
  • détermination automatique du sens de rotation ;
  • retournement du pont : 180° précis (à 0,1 mm près), avec détermination automatique du sens de rotation ;
  • 3 vitesses de rotation du pont disponibles par simple sélection ;
  • « Menu 255 » : utilitaire de mise au point qui permet de relever la position de chaque voie par rapport au « point zéro » de façon à renseigner le programme principal ;
  • « Menu 254 » : utilitaire pour une retouche fine du calage du « point zéro » ;
  • code « 253 » pour une réinitialisation « à chaud » du programme ;
  • mise sous tension des voies : automatique en fonction de la position du pont, et seulement après que l'alignement « pont-voie » soit effectif ;
  • commutations assurées par des relais commandés par les ARDUINO.
 
 
 
 
 
Je voulais disposer d'un pont tournant qui me permette de « tourner » mes Big Boy et autres « Cab Forward ».
 
Toutes ces locos ont des longueurs comprises entre 400 et 500 mm.
 
J'ai donc fabriqué un pont tournant « maison » de 520 mm.
La façon dont j'ai procédé n'est certainement pas la seule possible. Certains d'entre vous auront, je l'espère, de meilleures idées que les miennes.
 
Note 1 :
 
Dans tous les dessins et photos, je ne donne aucune cote : les dimensions dépendent beaucoup de votre projet.
 
Seuls les principes présentent un intérêt.
 
Note 2 :
 
Toutes les photos et dessins peuvent être agrandis en cliquant dessus.

 
Vue globale synthétique
DessinPont_2.png
Dessin_Pont_4.png
 
 
Comme dans la réalité, la fosse du pont est directement creusée dans la table de roulement (la planche qui représente le sol).
La profondeur de la fosse est d'environ 40 mm.
Le fond de la fosse est constitué par une plaque de contre-plaqué de 8mm.
L'ensemble est collé et constitue la partie inamovible de la structure.
 
La partie motrice est un sous-ensemble amovible.
La planche de base est en CP d'épaisseur 8 mm.
Elle porte le moteur pas-à-pas, le plateau et ses roulements de maintien, ainsi que le palier à roulement pour l'axe du pont.
 
Cet axe entraîne la partie tournante du pont.
 
La partie amovible est fixée à la partie inamovible par 4 tiges filetées
 

La fosse

 
 
Le mur circulaire de la fosse est fabriqué à partir d'une bande de bois (hêtre) d'épaisseur 2 mm, cintrée, emboîtée et collée à l'intérieur du trou pratiqué dans la planche de la table de roulement.
Si on veut que la fosse soit bien circulaire, il faut respecter plusieurs conditions :
  • le trou doit être parfaitement circulaire ;
  • la bande de bois doit avoir pile la longueur pour se monter en forçant légèrement et pour que, là où les deux extrémités de la bande se rejoignent, le raccord ne forme pas d'angle. Pour cela je préconise un pré-cintrage à la vapeur, surtout pour les deux extrémités de la bande ;
  • le collage doit être fait soigneusement pour que l'assemblage soit costaud et résiste aux contraintes dues à l'élasticité de la bande de bois ;
  • laisser sécher le collage au moins 24 heures.
     
 La plaque de fond de la fosse n'est pas circulaire. Elle est rectangulaire et dépasse largement le cercle de la fosse.
Elle est collée sous la bande de bois circulaire qu'on vient de mettre en place.
Il est impératif que cette plaque de fond soit le mieux possible parallèle avec la table de roulement.
 
Il est impératif que le collage soit de bonne qualité, voir même renforcé.
Dans les angles on remarque 4 trous.
Ils sont destinées à recevoir 4 tiges filetées de diamètre 10 mm, bloquées avec rondelles d'appui et écrous, recto et verso.  



 

La partie motrice


 
Cet ensemble est amovible.
Bien m'en a pris : la mise au point de la partie motrice, tests compris, s'est faite confortablement
« sur l'établi », sans être couché sous le réseau, les bras en l'air.
La mise au point du programme ARDUINO s'est fait de la même façon : le sous ensemble posé sur un établi.
 
La plaque du fond de la fosse est en CP de 8 mm. Elle a les mêmes dimensions que celle du fond de la fosse.
 
Elle supporte :
  • le support inférieur et son roulement pour guider l'axe vertical avec un minimum de frottements ;
  • la platine en aluminium (épaisseur 2 mm) qui maintient le moteur pas-à-pas et les roulements de guidage de la courroie crantée ;
  • les 4 supports pour les roulements de soutien du plateau tournant (photo de gauche ci-dessous) ;
  • les deux supports des switchs.
pont_mecanisme--8-.jpg
Dessin_Pont_8.png
Dessin_Pont_6.png
pont_mecanisme--9-.jpg
 
Il y a aussi un orifice de visite d'assez gros diamètre : il permet d'accéder depuis dessous au tendeur de courroie, quand l'ensemble du pont est en place sur le réseau.
Sur cette plaque on perce 4 trous, exactement vis-à-vis de ceux qui tiennent les tiges filetées sur la plaque de fond de la fosse.
Par contre ceux-ci seront percés au diamètre de 16 mm, et non pas 10 mm : c'est ce qui permettra – par le glissement possible dû au jeu entre le trou et la tige filetée – d'aligner les axes des roulements supérieur et inférieur et d'ajuster impeccablement la verticalité de l'axe d'entraînement.
           
 
 
 
 

Quelques vues de détails...

 

Le plateau tournant

(Sur la première photo ci-dessus à gauche, on aperçoit un plateau blanc en polyéthylène.

C'était mon premier essai non couronné de succès : contrairement à mon attente, le plateau s'est voilé de plusieurs millimètres ! )
Le plateau définitif a été tourné dans une plaque de contre-plaqué filmé de 12 mm.
La tranche du plateau porte la gorge qui reçoit et guide la courroie crantée.
La pièce rouge maintient une bonne perpendicularité entre l'axe et le plateau.
Elle a été réalisée en impression 3D (matière : PLA)
pont_mecanisme--1-.jpg
pont_mecanisme--13-.jpg

 

 

Le tendeur de courroie

Sur le plateau (ci-dessus) on aperçoit aussi l'envers du tendeur de courroie, encastré au plus près du bord.
 
Sur la première photo ci-dessous le recto du tendeur est vu à travers l'orifice de visite de la plaque de base.
 
A droite : l'envers du tendeur, la fente pour le passage de la courroie crantée et l'index qui viendra actionner les switchs.
 

L'entraînement de la courroie et les roulements de guidage

Sur la première vue, le plateau a atteint sa course maximale.
 
 
On aperçoit l'index (qui ne pourra pas aller plus loin), le switch de stop (en blanc) et une partie du switch de ralentissement (en jaune) avec son levier de commande.
Le moteur pas-à-pas et les galets à roulements sont fixés sur la platine rectangulaire en aluminium.
 
A droite, une vue de la poulie crantée du moteur et des galets.
Les galets permettent de réduire l'angle mort théorique de déplacement de l'index (donc du plateau) à quasiment rien : moins de 5°.
 
En fait l'angle mort est surtout donné par l'emprise du switch d'arrêt et de ses bornes de connexion.
 
Il faut compter que la zone « interdite », celle où l'index ne pourra pas aller, est de l'ordre de 6 centimètres, soit un angle mort réel d'environ 15°.
 
 
 
Les switchs et leurs supports
 
Les pièces de support sont réalisée en impression 3D.
 
Sur la vue de droite on voit l'index qui a effectué sa rotation vers la gauche.
 
Il vient d'actionner le levier du switch de ralentissement et va bientôt atteindre le switch de stop.
pont_mecanisme--11-.jpg
pont_mecanisme--2-.jpg
 
 
Note :
Dans la section « Téléchargements » je donne la totalité des fichiers 3D des pièces visibles sur ces photos.
 
Le tendeur de courroie
 
C'est certainement la pièce qui m'a donné le plus de mal à concevoir.
Et puis j'avais envie de rigoler un peu.
Ici il n'est pas possible d'utiliser un tendeur du style « ressort de pince à linge » —  comme sur certaines courroies d'imprimantes 3D —  tout simplement parce qu'il n'y a pas de zone où la courroie est libre.
 
Une des extrémités est engagée dans la boucle de blocage : le canal d'entrée est tel que les crans de la courroie s'interpénètrent et empêchent le glissement.
 
Premier problème résolu !
L'autre extrémité est glissée vers la fosse dans la quelle on a installé, tête en bas, une poulie crantée (exactement le même modèle que celle qui équipe le moteur pas-à-pas).
Le levier (la tige filetée vissée dans la poulie) permet alors d'entraîner la courroie qui ressort à la verticale grâce à la forme du canal de sortie.
 
 
Merci l'imprimante 3D
 
Une fois la courroie correctement tendue — suffisamment mais pas trop pour ne pas faire forcer le moteur — on bloque le levier du tendeur avec une vis.
Les résultats sont remarquables : il n'y a pas de jeu sensible dans la rotation du plateau ! Problème réglé !
 

 

 

Pont tournant :

 

SCHÉMA GLOBAL pour L'ARDUINO N°1

Schema_General_pont.png
.

 

Cool ! Il ne s'agit que de l'assemblage simple de sous-ensembles  « faits pour... »
 
Les entrées-sorties sont presque toutes utilisées !
 
Ci-dessous je détaille ce schéma, fonction par fonction.
 
 
Quelques précisions pour commencer...
 
Alimentations de puissance des ARDUINO et du driver :
  • pour des raisons de clarté je n'ai représenté aucune de ces alimentations ;
  • chaque ARDUINO est alimenté par un bloc 9 V DC / 1 A,
    du type de celui représenté ci-contre ;
  • le driver est lui aussi alimenté en 9 V DC / 1 A. (et non pas 12 V DC.
    Nous verrons plus loin la raison de ce choix) ;
  • je n'ai pas non plus représenté les modules relais connectés à l'ARDUINO N°2.
     
    Ceci fera l'objet d'un article séparé.
Une seule alimentation 9 V DC aurait pu suffire pour alimenter ces trois éléments.
Cependant j'ai trouvé préférable que chaque « consommateur » ait sa propre alimentation.
 
J'aime bien fractionner les problèmes : pour la mise au point et en cas d'intervention il est plus commode de pouvoir débrancher une partie seulement des circuits.
 
D'autre part, dans le cas d'une alimentation unique, le fonctionnement du moteur pas-à-pas occasionne un appel de courant qui risque de faire fluctuer la tension d'alimentation des deux ARDUINO, ce qui n'est pas souhaitable.
 
Conséquence d'un système avec des alimentations séparées
Il est absolument impératif que les deux ARDUINO et le driver aient une masse commune :
  • Gnd ARDUINO N°1 ⇔ Gnd ARDUINO N°2 ;
  • Gnd ARDUINO N°1 ⇔ « Power Gnd » du driver.
 
Alimentations 5 Volts (relais, LCD, HC-05) 
Les arrivées « Gnd » et « +5V» sont représentées seulement sous forme de deux traits courts, bleus et rouges :
  • le fil bleu correspond à « Gnd » pris sur l'ARDUINO N°1 ;
  • le fil rouge correspond au «+5V  » pris sur l'ARDUINO N°1.

 

Liaison ARDUINO N°1 ⇔ ARDUINO N° 2

L'ARDUINO N° 2 est l'esclave de l'ARDUINO N°1.
Les deux ARDUINO ont — nous l'avons vu — une masse commune.
Ils sont de plus connectés par la liaison série :
« Tx ARDUINO 1 (broche 1) ⇔ Rx ARDUINO 2 (broche 0) ».
Schema_x2_ARDUINO.png
 
ATTENTION : cette liaison doit être débranchée quand on téléverse le programme
dans l'un ou l'autre ARDUINO.

 
Liaison HC-05 ⇔ ARDUINO N°1
Le HC-05 est un module de transmission BLE.
Dans cette application, seule sa broche « Tx » est utilisée pour transmettre à l'ARDUINO N°1 les ordres en provenance de l'application ANDROÏD.
« Tx du HC-05 ⇔ broche 13 de l'ARDUINO N°1 ».
Le HC-05 est alimenté en 5 Volts par l'ARDUINO.
Note : dans le cas de cette application, on peut indifféremment utiliser un HC-05 ou un HC-06.
Schema_HC-05.png
 

Liaisons LCD ⇔ ARDUINO N°1 ; liaison clavier ⇔ ARDUINO N°1

Un de mes petits fils a fortement insisté pour disposer d'une commande fixe, sur la console (avec un clavier et un écran LCD), en plus de la commande par l'application ANDROÏD.
Comment résister à un enfant de 9 ans quand il a une
bonne idée, qui de surcroît m'oblige à me creuser la tête ?
La liaison « écran LCD ⇔ ARDUINO » mobilise 2 entrées de l'ARDUINO N°1 ;
La liaison « clavier ⇔ ARDUINO » mobilise 7 entrées.
Schema_Clavier_Ecran.png
LCD ⇔ ARDUINO
SDA (fil jaune) ⇔  broche « A4 » (18)
SCL (fil vert) ⇔  broche « A5 » (19)

Clavier ⇔ ARDUINO
broche 1 (fil gris clair) ⇔  broche 11
broche 2 (fil gris) ⇔  broche 9
broche 3 (fil vert) ⇔  broche 12
broche 4 (fil jaune) ⇔  broche 6
broche 5 (fil marron) ⇔  broche 10
broche 6 (fil rouge) ⇔  broche 7
broche 7 (fil bleu) ⇔  broche 8

Liaison ARDUINO N°1 ⇔ Driver et moteur pas à pas
La liaison avec le driver du moteur nécessite 4 fils, donc 4 sorties de l'ARDUINO N°1.
ARDUINO broche 2 ⇔ IN1 du driver
ARDUINO broche 3 ⇔ IN2 du driver
ARDUINO broche 4 ⇔ IN3 du driver
ARDUINO broche 5 ⇔ IN4 du driver
 
Ne pas oublier la liaison de masse avec l'ARDUINO :
Gnd ARDUINO N°1 ⇔ « Power Gnd » du driver.
Les bobines du moteur pas-à-pas sont connectées aux sorties
« Output A » et « Output B » du driver, conformément aux spécifications du moteur utilisé.
Schema_Stepper_Motor.png
Ci-dessus trois vues du driver avec son connecteur additionnel à 4 bornes, soudé sous le circuit :
  • x1 sortie + 5 Volts ;
  • x2 « Gnd » au centre ;
  • x1 entrée 12 Volts .
     
Ce connecteur supplémentaire m'a permis de brancher le petit ventilateur de refroidissement du driver (image de droite).
Il permet aussi de relier la masse du driver avec celle de l'ARDUINO (flèche verte).
 
La tension d'alimentation du moteur pas-à-pas est raccordée sur le bornier à vis de couleur bleue.
 
Tension d'alimentation du moteur pas-à-pas :
Les caractéristiques du moteur permettent normalement de le faire fonctionner avec une tension de 12 Volts max.
J'ai finalement opté pour une tension de seulement 9 V DC.
En effet, lors de mes essais avec une tension de 12 Volts, j'ai constaté un échauffement important du moteur et du driver.
Il faut dire que le moteur a été méchamment sollicité pendant plus d'une heure, sans arrêt, pour tester la répétitivité des positionnements !
Sous 9 Volts, le couple du moteur est encore largement suffisant pour l'entraînement du pont, mais avec une tension de 6 Volts, j'ai parfois constaté des « décrochages » du moteur qui rate des pas.
Donc j'ai opté au final pour une alimentation sous 9 V DC.
D'autre part, le programme comporte une fonction qui coupe le moteur à la fin de chaque déplacement : économie d'énergie, mais surtout limitation de l'échauffement.
Un petit ventilateur refroidit le driver du moteur.

 

Liaisons avec les switchs

« Slow switch » et « Stop switch » sont les noms que portent ces deux contacts dans le sketch ARDUINO.
Ils sont utilisés pour le calage de la position « zéro » du pont, qui a lieu lors de chaque mise sous tension de l'ensemble.
 
« Slow switch » donne l'ordre de ralentir le moteur avant d'atteindre le point zéro, de façon que le « Stop switch » ne soit pas actionné en pleine vitesse.
Et puis c'est plus réaliste.
« Slow switch » ⇔ broche « A0 » (14) sur ARDUINO N°1
« Stop switch » ⇔ broche « A1 » (15) sur ARDUINO N°1
Les liaisons utilisent un câble blindé à 2 fils + la tresse.
(Un fil micro souple convient très bien).
Schema_Switchs.png
Pourquoi un câble blindé à deux fils ?
(Blindé mais pas coaxial).
Si on décide de ne pas installer la petite console « clavier + écran » et de ne travailler qu'avec l'application ANDROÏD, alors il n'y aura pas de problème : on peut installer tout le système électronique ci-dessus au plus près du mécanisme du pont tournant, avec des longueurs de fils minimales.
 
Si comme dans mon cas on utilise les deux possibilités, le système électronique est nécessairement proche de la petite console, mais loin du pont tournant et en particulier des deux switchs (un peu plus de 2 mètres sur mon réseau).
 
On risque alors qu'un câblage des switchs simplement constitué de 2 fils non blindés transmette des parasites à l'ARDUINO.
 
L'utilisation d'un câble à 2 fils blindés supprime ce risque.
 
Oui, mais à condition de le câbler dans les règles de l'art :
Les 2 fils du câble blindé sont soudés sur les bornes du switch.
Le rouge est relié à l'entrée ad hoc sur l'ARDUINO.
Le bleu est relié à « Gnd ».
La tresse est reliée à « Gnd » mais 
seulement du côté ARDUINO.
Schema_Switch_2.png
 
La tresse est interrompue au plus près des bornes du switch, mais sans qu'il y ait contact avec la borne du fil bleu (ni l'autre, bien entendu).
 
Note :
La couleur des fils n'est donnée ici qu'à titre indicatif pour faciliter les explications.

 
 
Liaison avec les deux relais d'inversion de polarité
 
Les deux relais (sur un seul module) sont commandés en même temps.
En effet, ce sont des relais 1RT.
Il en faut donc 2 pour fabriquer un inverseur de polarité.
Ces relais participent à la gestion du courant de traction du pont et des voies de garage.
 
(Les schémas de câblage de l'ensemble des relais sont traités dans un autre article).
 
IN1 et IN2 du module RELAIS reliés ensemble.
IN1/IN2 RELAIS ⇔ broche « A2 » (16) de l'ARDUINO N°1

 
Petit truc
Vous avez sans doute remarqué que le nombre de broches « Gnd » et de broches « 5V » sur la carte ARDUINO UNO est très nettement insuffisant pour permettre d'établir toutes les liaisons de masse et de +5 Volts nécessaires.
 
Il est utile de se bricoler une petite platine qui permet de multiplier les broches « +5V » et « Gnd » et ainsi de distribuer facilement le +5V et la masse.
 
Bon, d'accord, le support 3D c'est du luxe...
... mais c'est tellement pratique !
 
Ci-joints les fichiers correspondants « .stl »« .rsdoc » :
Download_1.png
 

Sketch pour l'ARDUINO N°1

Download_1.png
 
Le texte du sketch « ARDUINO_PONT_KEYPAD_LCD_V23k » comporte environ 940 lignes, dont une bonne partie est constituée de commentaires.
Téléchargement ci-dessus.

En fait ce sketch n'est impressionnant que par sa taille mais pas par sa complexité.
J'ai évité le plus possible de recourir à une programmation alambiquée, qui aurait été sans doute plus élégante mais moins facilement compréhensible et moins facilement modifiable.
 

Les commentaires intégrés
 
Ils me servent de pense-bête personnel.
Je n'irais pas jusqu'à dire que tout est expliqué dans ces commentaires, mais presque.
La ligne de commentaire ci-dessous sur fond rouge (aux environs de la ligne 90)...

/*  NOTE SUR LA CONNEXION ENTRE LES DEUX ARDUINO :
 *  ARDUINO n°1 Tx --> ARDUINO n°2 Rx. (La liaison ARDUINO n°1 Rx --> ARDUINO n°2 Tx n'est pas nécessaire) ;
 *  Les masses doivent être reliées ensemble, sinon les deux ARDUINOS doivent être sur la même alimentation ;

 *  !!! IMPERATIF : COUPER LA LIAISON Tx --> Rx AVANT LE TELEVERSEMENT (sinon blocage du téléversement)
*/

... est certainement une des plus importante à garder en mémoire.
 
J'ai même pris la précaution de l'écrire sur un petit carton posé près de mes deux ARDUINO.
En effet, si on oublie de débrancher cette liaison, l'IDE affiche un message d'erreur, mais sans expliquer clairement le problème !
 

 
Les bibliothèques additionnelles
L'IDE ARDUINO propose plusieurs bibliothèques, mais elles ne couvrent pas tous les besoins, ou alors elles n'ont pas l'efficacité voulue.
On trouve sur le net de nombreuses bibliothèques complémentaires.
Il est indispensable de télécharger et d'installer les bibliothèques ci-dessous pour que l'écriture et la compilation du sketch puisse se faire.
 
Il s'agit des bibliothèques :
StepperLab3.h
LiquidCrystal.h
LiquidCrystal_I2C.h
Keypad.h

 
Datasheet du clavier : ICI


 
Table de correspondance « n° voie ⇔ n° du pas du moteur pas-à-pas »
Entre les lignes 320 et 520 (environ) se trouve une des plus importantes fonction :
int traitementNumeroVoie(int num_Voie)
 
La table «switch (num_Voie) ... case xx : » contient la correspondance entre le numéro de voie sélectionné et le numéro du pas pour le moteur pas-à-pas.

switch (num_Voie) // "num_Voie" est une variable locale
    {     
    case 0:
      positionVoie = 0 ;
      initialisationPositionPont() ;
      break ;  
    case 1:
      positionVoie = 274 ;      
      break;
    case 2:
      positionVoie = 725 ;
      break;
    case 3:
      positionVoie = 1217 ;
      break ;  
    case 4:

...

 case 113:
      positionVoie = 13383 ;
      break ;  
    case 114:
      positionVoie = 4102 ;
      break;
    case 115:
      positionVoie = 5170 ;
      break;
    case 116:
      positionVoie = 5543 ;
      break ;
    case 117:
      positionVoie = 6076 ;
      break ;

...

Non, il n'y a pas 117 voies !
  • les voies sont codées de 1 à 17 quand le pont y accède par son extrémité « directe ».
  • elles sont codées de 101 à 117 quand c'est l'extrémité « opposée» qui se présente en face de la voie.
(voir les commentaires intégrés dans le sketch).
 
Mais ce n'est pas tout !
 
... accès à quelques commandes

 

Un certain nombre de codes « exotiques » correspondent à des commandes et non à des numéros de voies :

 

if (num_Voie == 222) // Ce code commande le retournement du pont
      {
      if (voieEnCours <= 17) {num_Voie = voieEnCours + 100 ; }

...

 

    case 60:
      vitessePont = 600 ;       
      codeVoie = voieEnCours ;
      Message_LCD1602_VitesseDuPont() ;

...

 

    case 255:           // Détermination manuelle de la position des voies
      vitessePont = 1000 ;
      codeVoie = 0 ;
      Message_LCD1602("MENU 255", "POSITION VOIES", 4000) ;
      determinationPositionsVoies() ;
      break ;

...

    case 253:
      hotReset() ;
      break ;
    case 254:           // Modification de l'offset
      vitessePont = 1000 ;
      codeVoie = 0 ;
      Message_LCD1602("MENU 254", "Modif. OFFSET", 2000) ;
      determinationOffset() ;
      hotReset() ;      // Reset à chaud du programme
      break ;

C'est certainement moins élégant que la mise en place de menus hiérarchisés, mais vu le petit nombre d'options (7 au total) c'était plus simple et cela allège grandement l'écriture du sketch.
L'utilisation de ces codes est expliquée dans l'article « 08-Mode d'emploi ».
 
Note 1 :
Au départ de mon projet, la fonction « determinationPositionsVoies() » faisait partie d'un programme indépendant. Ce programme ne sert qu'une seule fois puisque, quand les positions des voies sont connues et reportées dans le programme principal, il n'a plus d'utilité.
Or il était très très peu différent du programme principal.
Pour m'amuser, je l'ai donc intégré dans le programme principal, sous forme d'une fonction.
En fait, l'accès à ce menu « 255 » n'est utile que si on doit ajouter une 18ème voie (ou plus), ou si on doit déplacer une voie existante.
 
Note 2:
L'instruction « hotReset() ; », utilisée dans « case 253: » et « case 254: », fait appel à la procédure :
 

void(*hotReset) (void) = 0 ;          // Déclare la fonction Reset @ adresse 0


... qui est insérée juste avant « void setup() ».
J'ai utilisé le nom « hotReset » pour faire celui qui connaît 2 mots d'anglais...
 
En réalité c'est plus court que « redemarrage_a_chaud ».
On peut choisir le nom qu'on veut du moment qu'il est explicite.
oui, bon, ça va...

 

 

void saisieNumeroVoie()
 
Cette fonction traite à la fois les ordres en provenance du clavier et ceux en provenance de l'application ANDROÏD.
Dans les deux cas, le numéro de la voie sélectionnée est affiché sur l'écran LCD de la petite console.

 
Arrêt d'urgence

int arretUrgence()
{
  char emergency = '0' ;                         // Effacement du dernier caractère saisi avant nouvelle saisie

    emergency = kpd.getKey();                    // scrutation du clavier   
    if (emergency == '#' || emergency == '*' || (char) (HC_05_Pont.read()) == '#' )   // ... si une touche '#' ou '*' est reçue
       {
       return(1) ;       
       }
    else
       {
       return(0) ;
       }  // Fin de "if (emergency...)"
}         // Fin de void arretUrgence()
 

Si le clavier ou l'application ANDROÏD envoie un des deux codes « # » ou « * » seul, alors ce code est interprété comme un ordre d'arrêt d'urgence.
Cet arrêt d'urgence permet d'éviter ceci (par exemple) :
 
Jusqu'à maintenant je n'ai jamais eu besoin  d'utiliser ce code mais mes petits enfants trouvent ça très amusant !
 
Après un arrêt d'urgence, il est recommandé d'utiliser le code « 253 » (voir ci-dessous) pour recaler le pont.
 

 
void arretMoteur()

void arretMoteur()
{
    digitalWrite(2,HIGH);
    digitalWrite(3,HIGH);
    digitalWrite(4,HIGH);
    digitalWrite(5,HIGH);  
}
/* Coupe la consommation du moteur lorsqu'il n'est plus en mouvement.
// ATTENTION ! dans ces conditions le moteur est libre et tourne facilement à la main.
// Malgré tout il est utile de couper l'alimentation du moteur,
// sinon il chauffe : environ 4 Watts sous 5 volts et plus de 12 Watts sous 12 volts !
// Dans ce dernier cas le moteur devient vite brûlant.

 
Cette procédure est indispensable pour les raisons ci-dessus (commentaire).
Bien entendu il faut veiller à ne pas bousculer le pont quand il est à l'arrêt.
Au cas où cela se produirait, ou en cas de doute, il suffit d'utiliser le code « 253 » pour recaler le pont.


 
Transmission vers ARDUINO N°2
 

void transmissionVersARDUINO_2()  // transmet le numero de voie à l'ARDUINO n° 2 sous forme int  
    {
    if (codeVoie > 100) {Serial.write(codeVoie - 100) ; }
    else {Serial.write(codeVoie) ; }

    Serial.print("codeVoie =  ") ;     // pour controle sur moniteur
    Serial.println(codeVoie) ;

    }   
 

Très simple.
C'est la dernière instruction de la boucle principale « void loop ».
C'est donc seulement quand le pont a atteint sa destination que l'ARDUINO n°2 reçoit l'ordre de commutation des voies.

 
void setup ()
 

void setup()
{   
  pinMode(StopSwitch, INPUT_PULLUP) ;
  pinMode(SlowSwitch, INPUT_PULLUP) ;
 

...


  initialisationPositionPont() ; // (une seule fois à l'allumage de l'ARDUINO)
            // utilise Message_LCD1602("CALAGE DU ZERO", "EN COURS...", 3000) ;
            // utilise Message_LCD1602("PONT TOURNANT OK", "Numero voie ?", 3000) ;


} // Fin de "void setup"

 
Si l'ARDUINO a été éteint « à l'arrache », ou s'il y a eu une coupure de courant... le pont est stoppé dans une position qui n'est pas connue de l'ARDUINO.
Le rôle de l'instruction surlignée en vert initialisationPositionPont() ; est de réaliser le calage du pont à chaque démarrage de l'ARDUINO.
Ainsi tout le système est remis dans un état « propre ».
Cette instruction figure dans « void setup() ». Elle n'est donc exécutée qu'une fois.
 
Note :
J'aurais pu programmer une mémorisation « à la volée » de la position du pont en EPROM, et ainsi connaître la position exacte qu'il occupait au moment de l'arrêt du système.
Pas si exacte que ça !
  • les phénomènes transitoires, lors de la coupure des alimentations du système, ne garantissent pas que la position exacte du pont ait eu le temps d'être mémorisée ;
  • à l'arrêt (tension coupée) le moteur pas-à-pas n'est pas verrouillé en position : son axe tourne très facilement.
    Si on touche le pont lui-même, on peut être assuré que sa position aura changé, ne serait-ce que de quelques fractions de mm.
    La mémorisation de la position n'aura donc servi à rien ;
  • d'autre part, la mémorisation « à la volée » mobilise le processeur à chaque pas du moteur ! Un ralentissement important du programme en découle.
 
 
 
Sketch pour l'ARDUINO N°2
 
Difficile de faire plus simple.
 
void loop ()

void loop()
{
receptionNumVoie() ;
 
commutationRelaisVoies() ;         
}
 

On peut se passer d'explications pour cette boucle principale.


 
Définition des sorties
(partie en cours de vérification)
 

#define relaiVcc_1 2   // relai n°1 sur sortie n°2, etc.
#define relaiVcc_2 3
#define relaiVcc_3 4
#define relaiVcc_4 5
#define relaiVcc_5 6   // x5 relais pour commuter le Vcc
#define relaiGND_6 7   // et x4 relais pour commuter la masse
#define relaiGND_7 8
#define relaiGND_8 9
#define relaiGND_9 10

 
Oui. C'est la seule originalité .
Au lieu d'utiliser 17 relais (en réalité 5 modules de 4 relais, soit 20 relais), on n'en utilise que 9. Ils commutent les voies de façon matricielle :
4 lignes x 5 colonnes (4x5 = 20, suffisant pour 17 voies).
Le véritable intérêt de cette matrice de relais n'est pas l'économie de prix, mais l'allègement du câblage.


 
void commutationRelaisVoies()
Cette procédure (fonction) fait appel à « RAZ_relais() », tellement simple que je ne la détaillerai même pas ici.
 
Remarque : il y a une 18ème voie programmée, au cas où...
 

void commutationRelaisVoies()


{
     RAZ_relais() ;
 
     if (voieAlimentee == 1) { digitalWrite (relaiVcc_1, HIGH) ; digitalWrite (relaiGND_6, HIGH) ; }
else if (voieAlimentee == 2) { digitalWrite (relaiVcc_2, HIGH) ; digitalWrite (relaiGND_6, HIGH) ; }
else if (voieAlimentee == 3) { digitalWrite (relaiVcc_3, HIGH) ; digitalWrite (relaiGND_6, HIGH) ; }
else if (voieAlimentee == 4) { digitalWrite (relaiVcc_4, HIGH) ; digitalWrite (relaiGND_6, HIGH) ; }
else if (voieAlimentee == 5) { digitalWrite (relaiVcc_5, HIGH) ; digitalWrite (relaiGND_6, HIGH) ; }
else if (voieAlimentee == 6) { digitalWrite (relaiVcc_1, HIGH) ; digitalWrite (relaiGND_7, HIGH) ; }
else if (voieAlimentee == 7) { digitalWrite (relaiVcc_2, HIGH) ; digitalWrite (relaiGND_7, HIGH) ; }
else if (voieAlimentee == 8) { digitalWrite (relaiVcc_3, HIGH) ; digitalWrite (relaiGND_7, HIGH) ; }
else if (voieAlimentee == 9) { digitalWrite (relaiVcc_4, HIGH) ; digitalWrite (relaiGND_7, HIGH) ; }
else if (voieAlimentee == 10) { digitalWrite (relaiVcc_5, HIGH) ; digitalWrite (relaiGND_7, HIGH) ; }
else if (voieAlimentee == 11) { digitalWrite (relaiVcc_1, HIGH) ; digitalWrite (relaiGND_8, HIGH) ; }
else if (voieAlimentee == 12) { digitalWrite (relaiVcc_2, HIGH) ; digitalWrite (relaiGND_8, HIGH) ; }
else if (voieAlimentee == 13) { digitalWrite (relaiVcc_3, HIGH) ; digitalWrite (relaiGND_8, HIGH) ; }
else if (voieAlimentee == 14) { digitalWrite (relaiVcc_4, HIGH) ; digitalWrite (relaiGND_8, HIGH) ; }
else if (voieAlimentee == 15) { digitalWrite (relaiVcc_5, HIGH) ; digitalWrite (relaiGND_8, HIGH) ; }
else if (voieAlimentee == 16) { digitalWrite (relaiVcc_1, HIGH) ; digitalWrite (relaiGND_9, HIGH) ; }
else if (voieAlimentee == 17) { digitalWrite (relaiVcc_2, HIGH) ; digitalWrite (relaiGND_9, HIGH) ; }
else if (voieAlimentee == 18) { digitalWrite (relaiVcc_3, HIGH) ; digitalWrite (relaiGND_9, HIGH) ; }
}

 
Sur l'ARDUINO N°2, pour commuter ces 18 voies, on utilise les sorties 2 à 10 (soit 9 sorties).
La table de commutation ci-dessus traduit le fonctionnement de la matrice des 9 relais.
 
En fait, le matriçage « 4 x 5 » à 9 relais permet de commuter 4 x 5 = 20 voies.
Or l'ARDUINO N°2 dispose de 18 sorties (puisque 2 broches sont mobilisées pour la liaison série avec l'ARDUINO N°1).
Avec 18 sorties qui commandent 18 relais on pourrait donc commander :
  • 80 relais (donc 80 voies) avec une matrice 8 x 10 ;
  • 81 relais (donc 81 voies) avec une matrice 9 x 9 ;
     
Ouch ! voilà qui ouvre des perspectives si 18 voies ne suffisent pas à votre bonheur !




 
Schéma de câblage des relais commandés par l'ARDUINO N°2
Schema_relais_ARDUINO_2.png
 
 
Chaque nœud de la matrice correspond au branchement d'une des voies, le fil rouge sur le rail gauche, le fil noir sur le rail droit.
L'inversion de sens de marche est assurée par un inverseur à 2 relais situé en amont et commandé par l'ARDUINO N°1.
 
Remarque :
Dans le sketch ARDUINO j'ai appelé les sorties pour les relais « relaiVcc_xx » et « relaiGND_xx » pour qu'il soit plus facile de comprendre le principe de la matrice de commutation : x5 relais commutent le « Vcc » et 4 relais commutent « Gnd » de la tension de traction.
Bien entendu, si on veut pouvoir changer le sens de marche il faut installer un inverseur à relais en amont de la matrice de commutation.
 
Ces relais inversent « + » et « - », c'est à dire « Vcc » et « Gnd » de la tension de traction.
 
La terminologie utilisée dans la procédure « void commutationRelaisVoies() » pour désigner les sorties qui commandent des relais de commutation des voies — « relaiVcc_xx » et « relaiGnd_yy » — n'est donc rigoureusement exacte que quand les relais d'inversion de marche sont au repos, mais il faut bien « baptiser » les sorties en question d'une façon explicite.
 
Sur le schéma ci-dessus, les désignations « Vcc » et « Gnd » sont remplacées par :
 
« TRACTION RAIL DROIT » et « TRACTION RAIL GAUCHE ».
 
Ça colle plus à la réalité mais c'est moins parlant du point de vue électrique.
 
 
L'application pour le pont tournant a été développée avec MIT App Inventor 2 « en ligne ».
Les fichiers « .aia » et « .apk » de l'application ANDROÏD sont disponibles (aussi)
dans la partie ci-dessous : « 09-Téléchargements ».
Vous pouvez donc modifier cette application à votre gré (grâce au fichier « .aia » ).
 
L'application ANDROÏD transmet les commandes par Bluetooth à un module HC-05 (ou HC-06).
La partie « 04-Liaison Bluetooth HC-05 » dans la série consacrée à la publication Télécommande à 16 canaux explique comment associer un HC-05 avec un appareil ANDROÏD.
 
Chaque module BLE a une adresse composée de 12 chiffres.
Pour que l'application ANDROÏD fonctionne, elle doit connaître cette adresse (identifiant).
 
L'application, telle qu'elle est proposée en téléchargement, affiche par défaut l'adresse « 00:00:00:00:00:00 ».
 

 
Changer l'identifiant du HC-05
Download_1.png

Appui long sur le bouton [Connexion]
(ou  [Pas de connexion])

(qu'il soit rouge ou vert).

⇒ une notification apparaît.

En haut, l'identifiant en cours.
(qui peut être 00:00:00:00:00:00)

 

Saisir le nouvel identifiant dans la fenêtre de saisie et valider.

⇒ une deuxième notification apparaît pour confirmer le nouvel identifiant.

Remarque : le bandeau de titre affiche le nouvel identifiant.

 
Le nouvel identifiant est gardé en mémoire dans l'appareil ANDROÏD : au prochain démarrage de l'application, c'est ce nouvel identifiant qui apparaîtra.
Si on doit réinstaller l'application (version modifiée par exemple), cet identifiant est aussi conservé en mémoire.
Si on désinstalle puis qu'on réinstalle l'application, alors il faudra refaire la manipulation ci-dessus.
 
Un appui bref sur le bouton [Connexion] établira la liaison avec le nouvel HC-05.
Voilà.
Ça doit fonctionner.
 
La partie « 08-Mode d'emploi » ci-dessous explique les détails du maniement de l'application.
 

 

 

Mode d'emploi du programme ARDUINO
 


 
 
Initialisation du pont tournant
 
À la mise sous tension de l'ARDUINO, l'écran LCD de la console déroule une séquence de message pour identifier l'application (titre, n° de version, auteur).
C'est juste pour le plaisir.
Ensuite le programme commande le cycle d'initialisation de la position « zéro » du pont.
C'est une étape très importante qui conditionne la suite du fonctionnement du pont.
Description du cycle :
  • si le pont est proche de la « voie 0 », il commence par s'en éloigner : il dégage vers la voie « 1 » jusqu'à ce que le « Slow switch » soit libéré ;
  • puis il revient vers la « voie 0 », actionne le « Slow switch » et ralentit
    par paliers ;
  • le pont dépasse la « voie 0 » et le palpeur atteint le « Stop swich » : le pont repart vers la « voie 0 » et s'arrête :
⇒  le calage automatique est terminé.
 
Au final l'écran LCD affiche qu'il est en attente de la saisie d'un numéro de voie ou d'un code.
À l'issue de ce cycle, il est prudent de vérifier visuellement que le pont est pile en face de la « voie 0 ».
 
(Si non il faut effectuer un recalage mécanique ou utiliser le « code 253 »).


Mouvement vers une voie
  • sur le clavier à 12 touches de la console, taper un numéro de voie compris
    entre 1 et 17 ou entre 101 et 117 ;
  • valider la saisie avec « * » ou « # ».
     
⇒ l'écran LCD affiche le numéro de voie sélectionné.
 
⇒ le LCD indique que le pont est en rotation vers la voie choisie ;
Le numéro du pas correspondant est affiché à droite : « / 725 », par exemple.
 
Le pont a démarré progressivement, a parcouru la distance vers la voie sélectionnée et s'arrête progressivement.
⇒ le LCD affiche le message ci-contre.
Note :
Ce n'est qu'à partir du moment où l'afficheur annonce « PONT EN DIRECT SUR VOIE xx » ou « PONT EN INVERSE SUR VOIE yyy » que le système est prêt à recevoir la commande suivante.


Retournement du pont
À la place d'un numéro de voie valide, taper « 222 » et valider avec « * » ou « # ».
⇒ le pont démarre et affiche « RETOURNEMENT EN COURS... ».
Au final, c'est l'autre extrémité du pont qui est en face de la voie précédemment choisie :
le pont est « en sens inverse » en face de la « voie 2 ».
 
On aurait obtenu le même résultat si on avait saisi le numéro de la voie opposée : par exemple « 102 » si on partait de la « voie 2 ».
Si maintenant on tape à nouveau le code « 222 », le pont repart pour se positionner « en sens direct », en face de la « voie 2 ».
 
Arrêt d'urgence
 
Pendant le mouvement du pont, si on tape « * » ou « # » le pont stoppe brutalement.
⇒ un message sur le LCD indique que l'arrête d'urgence est activé.
Régler le problème qui a motivé l'arrêt d'urgence, ou attendre au moins 5 secondes.
Taper un numéro de voie et valider ⇒ c'est reparti !


Vitesse de rotation du pont
 
Taper « 60 » et valider avec « * » ou « # ».
⇒ le LCD affiche le message suivant pendant environ 5 secondes...
 
⇒ ... puis de nouveau affiche le numéro de la voie en cours.
 
⇒ les futurs déplacements se feront à vitesse réduite : 60 pas / seconde.
De même —  dès que le système est prêt —  on peut taper « 200 » ou « 100 » pour sélectionner une vitesse rapide ou revenir à la vitesse standard.
 
Lorsqu'on éteint le système la modification de vitesse de rotation du pont n'est pas gardée en mémoire. Au prochain démarrage, c'est la valeur standard « 100 » qui sera de nouveau sélectionnée.
 
Note :
Dans la mesure où il n'y a pas de remontée d'informations de l'ARDUINO en direction de l'application ANDROÏD, cette dernière n'affiche pas la vitesse choisie depuis la console.
Un jour, peut-être...
Au contraire la console (écran LCD) affiche les modifications de vitesse effectuées depuis l'application ANDROÏD.


 
 
MENU 255 : détermination de la position des voies
Drôle de nom pour un menu !
Tout simplement parce que j'ai choisi d'utiliser le code 255 dans le sketch ARDUINO pour accéder à la partie du programme

qui permet la « détermination de la position des voies »  (de la même façon que j'ai choisi le code 222 pour le retournement du pont).
 
Taper « 255 » et valider avec « * » ou « # ».
 
⇒ le LCD affiche le message suivant pendant environ 5 secondes...
⇒ le programme attend un n° de pas.
Taper au clavier le numéro de pas désiré et valider avec « * » ou « # ».
⇒ le pont se déplace jusqu'au pas choisi.
Recommencer l'opération autant de fois que nécessaire pour obtenir la coïncidence exacte avec la voie visée.

 
 
Pour terminer et sortir du MENU 255, saisir « 0 » et valider :
⇒ le pont fait mouvement vers la « voie 0 ».
Quand le pont est arrivé à destination, le LCD affiche le message suivant pendant environ 5 secondes...
... puis il affiche le message ci-contre.

⇒ le système est prêt à recevoir un numéro de voie ou un code.
 

 
 
MENU 255 : détermination de la position des voies
 
Taper « 254 » et valider avec « * » ou « # ».
⇒ le LCD affiche le message suivant pendant environ 3 secondes...
... puis il affiche le pas de l'offset « en cours », càd celui qui est enregistré dans l'appli.
... et enfin le message d'invite pour saisir la nouvelle valeur de l'offset
Saisir la nouvelle valeur de l'offset et valider avec « * » ou « # ».
⇒ le programme indique que la nouvelle valeur est enregistrée dans l'EEPROM de l'ARDUINO.
⇒ le pont se déplace vers sa nouvelle position.
Recommencer l'opération autant de fois que nécessaire pour obtenir la coïncidence exacte avec la « voie 0 ».

 
 
Pour terminer et sortir du MENU 254, saisir « 0 » et valider :
 
⇒ l'écran affiche la nouvelle valeur implantée en EEPROM (pour contrôle)
⇒ le pont réinitialise sa position.
Puis, au final, l'écran affiche successivement les messages ci-contre...

⇒ le système est prêt à recevoir un numéro de voie ou un code.
 
 
CODE 253 : redémarrage « à chaud » du programme
 
Pour des raisons diverses, on peut avoir besoin de redémarrer le programme.
C'est le cas par exemple si on a fait un arrêt d'urgence et qu'on veut vérifier que le calage du « point zéro » est toujours correct.
 
La solution brutale consiste à couper les alimentations du système et de les ré-allumer.
Pas très élégant...
L'autre solution c'est de prévoir un redémarrage « à chaud » dans le programme ARDUINO.
 
Une des solutions qui permet d'opérer le redémarrage « à chaud » du programme est détaillée dans la partie
« 06-Sketch ARDUINO » ci-dessus.
 
Quand l'écran LCD de la console affiche « Saisir num. voie ou code... » il suffit de taper « 253 » et de valider par « * » ou « # ».
 
⇒ le programme redémarre et donc ré-exécute le cycle complet d'initialisation.
 
⇒ la valeur de l'offset mémorisée dans l'EEPROM est conservée. (La méthode de reset employée ici n'altère pas les infos stockées dans l'EEPROM).



 
Mode d'emploi de l'application ANDROÏD

 
Identifiant Bluetooth
Il est affiché entre parenthèses, en haut de l'écran.
Note :
SI vous utilisez plusieurs appareils ANDROÏD avec Bluetooth, il est prudent de noter sur un tableau Excel (ou un simple carton) les numéros d'ID de tous vos HC-05, avec leur utilisation.
Il est tout aussi utile de coller une gommette au dos de chaque HC-05, avec son I.D.
Les plus chevronnés pourront renommer les HC-05 avec un nom plus explicite en utilisant les commandes AT.
Sur le net on trouve de très bons tutoriels pour ça. Mon préféré est ici.
 

 
 
Les messages d'aide
 
L'écran de l'application affiche 3 menus :
RETOURNEMENT du PONT
MENU 255
Rotation 10 pas / seconde


⇒ les petites icônes bleues situées à droite permettent d'afficher des informations succinctes sur chacun de ces menus :
 
... pour le retournement
du pont
 
... pour le
MENU 255
 
... pour le choix de la vitesse de rotation du pont
 
... automatique en cas de non connexion BLE
 
Le message sur la quatrième capture d'écran (tout à droite) est affiché quand la liaison BLE est coupée.
 
La zone des messages affiche aussi des informations contextuelles lors des différentes utilisations de l'application (voir ci-dessous).


Connexion
 
Si on lance l'application ANDROÏD après avoir mis sous tension la partie électronique (ARDUINO et accessoires), alors la connexion entre l'application et le HC-05 s'établit  automatiquement, sans qu'il soit nécessaire d'intervenir.
 
La connexion est perdue si l'appareil ANDROÏD s'éloigne trop du HC-05, mais elle se rétablit toute seule dès qu'on se rapproche suffisamment du système électronique.
Un appui bref sur le gros bouton rouge marqué [Pas de connexion] permet de forcer l'établissement de la liaison BLE avec le HC-05 (et donc avec l'ARDUINO).
(Sauf bien entendu si le système n'est pas sous tension, ou si l'appareil ANDROÏD est trop éloigné).
Un appui bref sur le même bouton — quand il affiche [Liaison établie avec ARDUINO] —  coupe la liaison BLE.
(Utile et même indispensable si on veut passer la main sur cette application à un autre appareil ANDROÏD. En effet, un HC-05 donné ne peut être en communication qu'avec UNE SEULE application ANDROÏD à la fois).


Rappel
Lorsqu'on a mis sous tension le système électronique du pont tournant, le programme ARDUINO a tout d'abord commencé par initialiser la position de départ du pont.


Écran d'accueil
Peu de choses sur cet écran :
  • une zone de messages ;
  • une zone de saisie ;
  • six commandes.
 
Les fonctions de ces éléments sont détaillées ci-dessous.
 
L'utilisation du bouton de connexion et l'affichage du bandeau de titres ont été vus plus haut, en début de cet article.
L'icône BLE (bleue) à gauche du bouton de connexion n'est là que pour faire joli (pour l'instant).
 

Zone des messages
Elle affiche des informations contextuelles simples, en fonction des actions.


Rotation du pont (vers la voie 12, par exemple)
  • toucher la fenêtre de saisie pour faire apparaître le clavier ;
  • saisir le numéro de la voie souhaitée ;
  • valider avec les « engrenages ».
 
⇒ le pont démarre et s'arrêtera en face de la voie 12.
⇒ la zone des messages indique que le pont fait mouvement vers la
voie choisie ;
⇒ la même indication apparaît sur l'écran LCD de la console.
Pour réinitialiser la position du pont, il suffit de saisir et valider le numéro de voie « 0 ».
Attention :
Ne pas envoyer de nouvelle commande tant que le pont n'a pas atteint sa destination : elle risque de venir contrarier la commande en cours ou de ne pas être prise en compte.
Note 1 :
« 12 » et « 112 » représentent exactement la même voie, mais :
  • « 12 » correspond au pont en sens direct ;
  • « 112 » correspond au pont en sens inverse.
     
Note 2 :
Si on tape un numéro de voie hors des intervalles [1 à 17] ou [101 à117], la zone des messages affiche un message d'erreur.
Les codes 60, 100, 200, 222, 253, 254 et 255 sont rejetés aussi.
Arrêt d'urgence
Un appui bref sur le bouton [STOP] bloque la rotation du pont instantanément.
 
La position du pont est mémorisée, mais je conseille plutôt de réinitialiser le pont en tapant le numéro de voie « 0 », dès que le problème qui a motivé l'arrêt d'urgence a été résolu.
 
La console affiche le message correspondant.
 
 
 
Particularités : codes cachés
 
En dehors des numéros de voies compris entre 1 et 17 , et entre 101 et 117, il existe 5 codes qui seront interprétés comme des commandes :
  • code 222 : retournement du pont ;
  • codes 60, 100 et 200 : vitesse du pont ;
  • code 255 : accès à la détermination de la position des voies.
Sur l'application ANDROÏD ces codes ne peuvent pas être saisis à la place d'un numéro de voie, comme sur la console.
Ils sont générés seulement à partir des trois boutons :
  • RETOURNEMENT du PONT ;
  • MENU 255 ;
  • Rotation xxx pas / seconde.


Retournement du pont
Appui bref sur « RETOURNEMENT du PONT »
⇒ transmet le code « 222#» à l'ARDUINO.
Un message indique que ce code a été envoyé à l'ARDUINO.
⇒ le pont effectue un demi tour complet.
 
Le code « 222 » est affiché sur l'écran LCD de la console, ainsi que les indications concernant le mouvement du pont.


Vitesse du pont

Au démarrage de l'application, la vitesse de rotation du pont est préréglée sur 100 pas / seconde.
 
Cette valeur est indiquée en bleu : « Rotation 100 pas / seconde ».
 
Un appui bref sur ce texte le change en « Rotation 200 pas / seconde » et modifie la vitesse de rotation du pont.
 
Un nouvel appui bref le change en « Rotation 60 pas / seconde » (idem).
 
Enfin, un nouvel appui bref le change en « Rotation 100 pas / seconde » (idem)
etc, par rotation.


IMPORTANT :
 
Le choix de la vitesse de rotation du pont doit se faire AVANT de choisir et valider un numéro de voie.
 
Lorsqu'on sélectionne une nouvelle valeur de la vitesse il faut laisser 6 secondes entre chaque appui bref (si on doit passer de 100 à 60, par exemple, puisqu'il faut transiter par 200).
 
En effet, ces ordres sont transmis à l'ARDUINO qui affiche un message de confirmation sur la console (comme si on avait tapé le code sur la console). Ce message s'affiche pendant 5 secondes, mais on ne le voit pas sur l'écran de l'application ANDROÏD !
Pendant cette durée de 5 secondes, toute autre commande est interprétée comme un « arrêt d'urgence », qu'elle vienne du clavier de la console ou de l'application ANDROÏD.
⇒ le message « ARRET D'URGENCE ACTIF » apparaît sur la console mais pas sur l'application ANDROÏD.
Le non respect de ces précautions ne cause aucun ennui grave. Simplement on perd un peu de temps.
Cela dit, le changement de vitesse du pont n'est que très occasionnel.
 


MENU 255
 
Appui long sur « MENU 255 » :
⇒ le texte du menu devient « MENU 255 ACTIF ».
⇒ le message indique que, cette fois, ce n'est plus un numéro de voie mais un numéro de pas que l'on doit fournir.
 
Taper un n° de pas puis valider :
⇒ le pont se déplace ;
⇒ le message indique le n° du pas de destination.
 
Après l'arrêt du pont on tape une nouvelle valeur.
Par approches successives on amène le pont pile en face de la voie visée.
On relève alors le n° de la voie et le n° du pas correspondant.
Ces informations viendront compléter la table de correspondances du sketch ARDUINO. (voir article « 06-Sketch ARDUINO » ).
 
Note :
Pour chaque voie physique, on aura 2 positions à déterminer :
  • une pour le pont en direct (voie « xy » ) ;
  • une pour le pont en inverse (voie « 1xy » ).
 
Pour sortir du MENU 255, il faut faire un appui bref sur « MENU 255 ACTIF ».
⇒  cette sortie du menu s'accompagne d'un retour à la position « 0 » du pont.
 

 
Compléments

Si on manipule l'application ANDROÏD sans qu'il y ait de liaison BLE établie, l'écran affichera un message d'erreur « Error 507... » par exemple.

 
Ce message n'est pas généré par l'application, mais par l'appareil ANDROÏD lui-même, puisque c'est lui qui gère les communications BLE.

 
Le message disparaît au bout de quelques secondes.

 
 
 
CODE 253 : redémarrage « à chaud » du programme

Ce code n'est pas applicable à partir de l'application ANDROÏD.
That's all Folks !
 
 
 
 
Sketches ARDUINO
Application ANDROÏD
Ensemble des pièces 3D
 
Le cas échéant, je ne manquerai pas de mettre à jour ces différents fichiers.
 
Bibliothèques ARDUINO :
StepperLab3.h
LiquidCrystal.h
LiquidCrystal_I2C.h
Keypad.h
 
Datasheet du clavier : ICI

 

 

© 2020 par Hubert SPERI – Créé avec Wix.com

WIX.png

Ce site ne contient aucun fichier avec des données personnelles et ne stocke aucune donnée personnelle lorsqu'on se connecte.

INYO_3.png
This site was designed with the
.com
website builder. Create your website today.
Start Now