Une horloge comtoise motorisée avec un Arduino

Depuis quelques années j’ai aimé restaurer de vieilles horloges comtoises ici et là pour retrouver le charme des maisons de mon enfance. Cette mécanique simple est relativement précise sur l’horaire, engendre des bruits de balancier ou de cloche inoubliables. Les causes de pannes les plus fréquentes sont un problème de calage au sol car une comtoise exige d’être droite, des rouages encrassés, ou une pièce usée qui disperse l’énergie au point de devenir insuffisante pour le mouvement. Il est souvent possible, après calage et nettoyage, de les relancer.

Désireux d’installer une horloge comtoise sur une étagère pour des raisons de place, je n’ai pas eu d’autre choix que de remplacer le système de poids et de balancier par un petit moteur électrique. Rien de compliqué…en apparence !

Comtoise motorisée sans balancier ni poids

Commençons par identifier le matériel nécessaire pour la motorisation :

  • un moteur pas à pas pour faire tourner les aiguilles,  
  • un opto-switch (ou capteur optique)  pour repérer la position des aiguilles,  
  • un servo moteur pour actionner le marteau de cloche,
  • le tout piloté par un micro contrôleur Arduino complété d’un module RTC (Real Time Clock) qui lui donnera l’heure, et l’ensemble alimenté par une prise USB.

Pour ce faire, je n’ai conservé que les engrenages agissant directement sur les aiguilles et supprimé tous les autres.  

Mais voyons d’abord comment marche une comtoise classique. 

Schéma de fonctionnement d’une horloge comtoise avec son poids  vue de dessus

Le fil soutenant le poids est enroulé sur le tambour qui, par sa roue dentée, entraîne le pignon P1. Ce pignon P1  entraîne, via un ressort qui fait fonction d’embrayage, la roue dentée RD2 solidaire du pignon P2. Cet embrayage  permet de tourner les aiguilles à la main, pour la mise à l’heure, sans affecter le mécanisme. 

La roue dentée RD2 (72 dents) entraine le pignon P3 (36 dents) solidaire de l’axe de l’aiguille des minutes. Le pignon  P2 (15 dents) entraîne la roue dentée RD3 (90 dents) qui porte l’aiguille des heures. La roue dentée RD4 est reliée au  système d’échappement qui fait battre le balancier.  

On comprend donc que si P1 fait 1 tour, P2 fait aussi 1 tour mais que P3 (les minutes) en fait 2 pendant que RD3 (les  heures) en fait 1/6. 

Motorisation

Comme son nom l’indique, le moteur pas à pas ne tourne pas de façon continue mais fait des pas en fonction de la polarisation des bobinages qu’il contient. Noter qu’en face des 8 bobinages du stator, le rotor comporte 6 pôles qui vont donc chercher à s’aligner avec les bobinages. Seuls 2 peuvent s’aligner et, pour ce faire, vont devoir avancer d’un pas. 

Pour le faire fonctionner il faut donc un peu d’électronique pour distribuer les impulsions aux bobinages, dans la bonne séquence. La vitesse de rotation pas à pas dépend de la fréquence des impulsions.

Le moteur pas à pas de type 28YBJ-48 est piloté par un module de commande ULN003. Ce moteur très économique et de faible puissance est réducté dans un rapport 64/1 ce qui lui donne un peu de couple

 

 

Schéma de fonctionnement d’une horloge comtoise motorisée

Le moteur est placé en direct sur un axe portant un pignon de 8 dents qui entraîne dans un rapport 1/12 la grande roue dentée RD4 de 96 dents, laquelle entraîne RD2 via l’embrayage. Le couple est donc largement suffisant pour faire « monter » l’aiguille des minutes dont le moment, du fait de sa longueur, pourrait bloquer le moteur s’il n’était pas démultiplié.  

Sachant que le 28YBJ-48 doit faire 32 pas pour 1 tour et comporte une réduction 64/1, il faudra donc qu’il fasse 32 * 64 = 2.038 pas pour que l’axe en sortie de réduction fasse 1 tour. 

Sa précision angulaire est donc grande soit 360° / 2.038 = 0,17° par pas.  Il est donc assez précis pour une horloge.

Pour que  RD2 qui commande les aiguilles exécute 1 tour, ce qui correspond à 2 heures, il faudra que le moteur avance de 2.038 * 12 = 24.456 pas soit 12.228 pas pour 1 heure. Cela correspond à 12.228 / 3.600 = 3,4 pas toutes les secondes. 

Déplacement des aiguilles

Selon son rayon, le déplacement linéaire de l’extrémité de l’aiguille des minutes d’une horloge comtoise est de l’ordre du cm. Pour un avancement visuellement fluide de cette aiguille, il faut la faire avancer « un peu » chaque seconde comme les comtoises mécaniques. Mais le calcul ne tombant pas juste, il faudra « réguler » c’est-à-dire faire 12.200 pas chaque heure, puis compléter d’un certain nombre de pas. Pour que le complément soit exact, il faut mesurer l’écart entre l’heure « mécanique » et l’heure « réelle » fournie par un module RTC DS1307 à quartz. 

Ce module comportant un quartz à 32.768 KHz est alimenté en permanence par une pile bouton CR2032 qui permet d’y stocker le temps.

 

 

Pour faire cette mesure d’écart, on va utiliser un opto-switch KTIR 311S comportant une diode émettrice et une cellule photo électrique. Si le rayon est interrompu on peut mesurer un signal.

Le signal sera déclenché une fois toutes les 2 heures par le passage entre les pattes de l’opto-switch (flèche jaune) d’un petit clou scotché (en attendant d’être soudé) à la roue dentée RD4.

Connaissant la position du clou (flèche rouge) sur la roue dentée, et donc l’heure « mécanique », il est facile de calculer l’écart de temps avec l’heure « électronique » qui nous est donnée par le RTC et de déterminer le nombre de pas de rattrapage nécessaire. Si le clou passe dans l’opto-switch avec 5 secondes de retard en 2h, le programme commande une rotation  complémentaire du moteur de 17 pas. Au prochain passage 2h plus tard, nouveau calcul d’écart, et nouvelle correction si besoin.  

Notre horloge est donc toujours en retard de 0 à 20 secondes maximum sur 2 heures. C’est presqu’indécelable visuellement en raison de l’épaisseur de l’aiguille des minutes et surtout le retard ne se cumule pas puisque la correction est effectuée toutes les 2 heures. L’aiguille des heures étant liée mécaniquement à celle des minutes avance imperceptiblement et ne pose aucun problème.

Cependant le module DS1307, très économique, dérive lui-même d’environ 1 seconde par jour soit 30 secondes par mois. C’est beaucoup mieux que la comtoise mécanique qui dérivait facilement de 5 minutes par semaine et qu’on remettait à l’heure à chaque remontage hebdomadaire. Mais c’est inacceptable pour une horloge actuelle. Pour l’instant, le RTC est remis à l’heure tous les 3 mois. 

 

Il est possible d’atteindre la perfection avec l’ajout d’un module DCF77 recevant par radio l’heure atomique de Francfort. https://fr.wikipedia.org/wiki/DCF77

 

 

Programmation

Le programme stocké dans l’Arduino est conçu pour :  

  • permettre le démarrage à partir d’une position donnée des aiguilles,  
  • assurer l’avancement précis et régulier des aiguilles,  
  • faire les corrections éventuelles toutes les 2h,
  • faire sonner la cloche aux heures, voire de sonner les demies ou de l’arrêter à certaines heures. 
// PROCEDURE DE DEMARRAGE
// Rappel : 1) aiguille des minutes positionnée manuellement à -5 min de l'heure impaire précédent l'heure actuelle
// 2) POWER ON, 3) moteur avance jusqu'au marker, 4) calcul de l'écart de temps et donc du nb de pas à faire
// 5) moteur avance jusqu'à l'heure actuelle
// pour confirmer le démarrage : coup de sifflet, allumage LED verte et coup de cloche puis extinction LED
tone(SPK,2500,100);digitalWrite(LEDV,HIGH);frappe_cloche(1);digitalWrite(LEDV,LOW);
// mesure de l'écart de temps à la mise en route supposée faite vers -5 de l'heure vraie si heure vraie impaire
if((hour()%2) !=0) meca_h=hour()-1;
// et vers -5 de l'heure précédant l'heure vraie si heure vraie paire
else if((hour()%2)==0) meca_h=hour()-2;
// on fait avancer par foulées de 4 pas jusqu'à l'opto switch = marker
do RotationMoteur(4,Rapide,0,'A');
while (digitalRead(swPin)==LOW);
// quand on arrive au marker, swPin passe au statut HIGH. Pour marquer le passage : coup de sifflet et allumage LED verte
tone(SPK,2500,100);digitalWrite(LEDV,HIGH);cpt_rot=0;
// mesure écart exact temps RTC vs temps MECANIQUE. Au démarrage (MER) c'est toujours un retard de 2 à 3 minutes
dh=hour()-meca_h;dm=minute()-meca_m;ds=second()-meca_s;
// Information envoyée au moniteur série
timerDisplay();Serial.print("ECART A LA MER");Serial.print(dh);Serial.print(" ");Serial.print(dm);Serial.print(" ");Serial.print(ds);
retard_mer=3600*dh+60*dm+ds;// l'écart horaire est mécaniquement inférieur à 3h
pas_mer=retard_mer/0.315+retard_mer*0.18;//nb de pas, en théorie 0,3/sec + 18% pour le temps de rotation
pas_mer=pas_mer+offset_meca;// AJUSTEMENT FINAL RTC-MECA avec offset_meca de x pas pour cohérence aiguille/cadran
// le jeu mécanique est estimé à 30" soit 90 pas
// Marker trouvé : ON MET L'HORLOGE A L'HEURE RAPIDEMENT
RotationMoteur(pas_mer,Rapide,0,'D');
// on remet le cumul pas à zéro, on éteint LEDV, on désarme CTRL_MK et on RAZ cpt_rot=0
nbp=0;cpt_rot=0;test_mk_H=0;digitalWrite(LEDV,LOW);
timerDisplay();Serial.print("FIN ROT. MISE A L HEURE");Serial.print(test_mk_H);Serial.print(";;");Serial.print(nbp);
Serial.print(";");Serial.print(millis());Serial.println(";;");

Pour ceux que le pilotage du moteur pas à pas intéresse : 
https://retroetgeek.com/arduino/arduino-comment-utiliser-un-moteur-pas-a-pas-uln2003a-et-28byj-48/

Sonnerie de la cloche

La sonnerie est provoquée par un marteau qui vient frapper la cloche. Le bras de levier utilisé est calculé pour que le  marteau frappe franchement la cloche sans rester collé dessus. C’est un simple servo-moteur de type SG90 9G, équipé d’un bras comme il y en a dans de nombreux modèles radio commandés. 

Comtoise équipée du moteur, de l’opto-switch et du servo comme décrit ci-dessus.

Mise en route

Pour le démarrage, sachant que l’index (matérialisé par le clou) passe dans l’opto-switch à 57 min 30 sec des heures paires, il suffit de positionner l’aiguille des minutes 5 min avant l’heure impaire précédant l’heure actuelle puis de brancher l’alimentation. Le programme déclenche la rotation du moteur jusqu’à trouver l’index, qui envoie le signal à l’Arduino, mesure l’écart de temps (entre l’heure mécanique et l’heure du RTC) et calcule le nombre de pas à faire pour positionner correctement les aiguilles compte tenu de l’heure exacte actuelle. Même en tournant vite, il faut, selon l’heure réelle, entre quelques secondes et 30 ou 40 secondes pour y parvenir. Le nombre de pas est donc majoré proportionnellement à l’écart mesuré pour atteindre un positionnement de l’aiguille des minutes aussi exact que possible. Il sera toutefois ajusté 2 heures plus tard lors du prochain passage de l’index.

Contrôle des opérations

L’Arduino ne peut réaliser qu’une tâche à la fois comme : faire avancer le moteur, actionner la cloche, calculer un écart de temps etc… Par ailleurs, le moteur ne peut pas fonctionner sans arrêt sinon l’horloge avancerait d’une heure en 30 ou 40 secondes !

Il faut donc répartir les différentes tâches par cycles : minute ou heure, tout en faisant avancer le moteur souvent pour que le mouvement reste fluide visuellement.

Le choix retenu (parmi d’autres possibles) est de faire avancer le moteur 4 fois par minute. L’extrémité de l’aiguille des minutes va donc avancer visuellement d’environ 2,5 mm à chaque fois. C’est à peine plus que la largeur de la pointe. 

Le moteur devant faire théoriquement 12.228 pas / heure, doit donc en faire 203,8 par minute soit 4 fois 50 pas environ. Le calcul ne tombe jamais juste… Il est donc décomposé comme suit :

Nb de pas minute heure 2 heures
théorique 203,8 12.228 24.456
1 fois 51 2 n pas selon écart
3 fois 50
Total 201 2 + 60 * 201 4 + 120 * 201
12.062 24.124 + n >= 332

Toutes ces actions peuvent être tracées et enregistrées dans un fichier texte aux fins de contrôle, sous réserve d’inclure des commandes d’écriture comme Serial.print(variable) ; ou Serial.print(« Marker trouvé ») ;

Le module de commande ULN2003 envoie des impulsions espacées de 4 ms au moins (il faut bien laisser au moteur le temps de faire 1 pas !). Afin d’éviter la surchauffe, la pause entre 2 impulsions a été réglée à 25ms. Pour faire 50 pas avec une pause de 25 ms entre chaque pas, il faut donc 1.150 ms. De même, pour frapper la cloche 1 coup, il faut 1.220 ms. Pour frapper 12 coups, il faut près de 15 secondes si l’on veut espacer les coups d’une seconde pour imiter une sonnerie mécanique.

Il s’en suit qu’il faut soigneusement planifier les différentes tâches au cours d’une minute, d’une heure et 1 fois toutes les 2 heures.

de HH:00:00 à HH:00:03 écriture sur le moniteur série de l’état de différents paramètres et initialisation des variables. Les compteurs d’heure et minutes « mécaniques » sont incrémentés. Armement de la sonnerie.
de HH:00:03 à HH:00:15 frappe de 1 à 12 coups de cloche. Les coups non frappés sont remplacés par des pauses Delay(1220) ; pour conserver le temps total de 12 coups.

à HH:MM:20 on fait une rotation de 50 pas + 1. Durée=1.220 ms environ
à HH:MM:30, 40, 50 on fait une rotation de 50 pas pendant 1.150 ms environ. Le total fait 201 pas par minute

à HHPaire:55:00 on arme le recalage bi-horaire
à HH:55:01 on exécute un recalage horaire de 2 pas, volontairement insuffisant par rapport au théorique
à HHPaire:56:01 on arme l’opto-switch et on attend le passage du clou. Quand le clou déclenche le signal, on calcule l’écart temps et on exécute le nb de pas supplémentaires requis.

Le moteur et les composants électroniques nécessaires peuvent être achetés :
– à Paris chez Saint Quentin Radio, 6 rue de Saint Quentin 75010 Paris, petite boutique à l’ancienne avec vendeurs prodiguant des conseils fort utiles. On peut y acheter 1 seule résistance à 0,20 Eur…
Leur site permet également la commande à distance. https://www.stquentin-radio.com/

– en France en vente à distance, GOTRONIC. Très efficace et rapide. https://www.gotronic.fr/

– plus loin et un peu moins cher mais avec délais, BANGGOOD. https://www.banggood.com/fr/

0 Comments on “Une horloge comtoise motorisée avec un Arduino

  1. Bonjour,
    Une comtoise qui peut prendre sa place sur un voilier et qui ne craint pas le mal de mer !
    Merci pour le sujet.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *