Projet Arduino pour Horloger (amateur et peu fortuné)

[Cadrature]

Bonjour

Pour tous ceux qui sont intéressés, je fais un point.
Une petite modification du code de mon système pour le rendre
fonctionnel simplement.

Montage:
Une plaque à essai
Des fils pour plaque à essais
1 Arduino Uno
3 LED (verte rouge et bleue)
3 Résistances (entre 720 et 1000 ohm)
1 DS3231
1 LCD2004
2 LMS393
Liste d’environ 50€ à 60€ TTC

Branchement:
1 LMS393 de détection pendule sur D2 (attention, c’est important de prendre un pin qui accepte interruption)
1 LMS393 de détection sonnerie sur D3 (attention, c’est important de prendre un pin qui accepte interruption)
LED montée avec résistance en série sur D8, D9, D10
DS3231 et LCD2004 sur SDA et SDL, c’est-à-dire A4 et A5

Réglages:
Le code prévoit
– un temps de mesure de référence de 12h00,
– un temps de rebond de la sonnerie de 11h50 (temps pendant lequel on ne fait
plus de mesure sur la sonnerie),
– un temps de rebond du pendule de 700ms (temps pendant lequel on ne fait
plus de mesure sur le pendule).

Fonctionnement:
On fait en sorte que LMS393 de détection pendule soit coupé par le pendule (flash de LED verte)
On fait en sorte que LMS393 de détection sonnerie soit coupé par marteau de sonnerie (flash LED rouge)

On attend une première sonnerie (flash LED bleu), un décompte se fait pendant 11:50 heures et toutes les autres sonneries sont ignorées (flash rouge mais pas bleu)

Sonnerie 12h00 après et affichage
– Temps chronométré pour 12h00 de l’horloge en ms
– Différence entre ce temps et 12h00 étalon sur horloge DS3231 en ms. C’est-à-dire l’avance ou le retard en ms/12h
– Nombre d’oscillations pour ces 12h00 horloge

Attente sonnerie suivante et on recommence…

Code:

Code:

/*
 * This program is free software: you can redistribute it and/or modify it under the terms of the GNU
 * General Public License as published by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
 * the GNU General Public License for more details.
 *
 * Cadrature 2024
 */

#include <Arduino.h>

// Constants
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include « RTClib.h »

#define IR_PENDULUM_PIN 2 // IR sensor for the pendulum
#define IR_CHIME_PIN 3 // IR sensor for the chime strikes
#define GREEN_LED 8
#define RED_LED 9
#define BLUE_LED 10

// LCD setup
LiquidCrystal_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20×4 display

// RTC setup
RTC_DS3231 rtc;

// Time synchronization
unsigned long lastSyncMillis = 0;
DateTime rtcAtLastSync;
unsigned long SYNC_INTERVAL_MS = 6000; // Synchronization interval with RTC

unsigned long pendulumOscillations = 0;
unsigned long pendulumMs = 0;
unsigned long lastPendulumMs = 0;
unsigned long PENDULUM_DEBOUNCE_MS = 700; // Debounce time for pendulum detection

unsigned long CHIME_DELAY_MS = 12 * 3600000 – 10 * 60000; // 12 hours – 10 minutes
unsigned long measuredChimeIntervalMs = 0;
unsigned long REFERENCE_CHIME_INTERVAL_MS = 12 * 3600000; // Reference time for 12 hours

bool greenState = false;
unsigned long greenStartMs = 0;
const unsigned long GREEN_DURATION = 20;

bool redState = false;
unsigned long redStartMs = 0;
const unsigned long red_DURATION = 60;

bool blueState = false;
unsigned long blueStartMs = 0;
const unsigned long blue_DURATION = 60;

// Display update timing
unsigned long lastDisplayUpdateMs = 0;
const unsigned long DISPLAY_UPDATE_INTERVAL_MS = 1009;

// IR detection
bool chimeDetected = false;
bool pendulumDetected = false;

unsigned long currentTimeMs;

unsigned long lastChimeMs;

enum State
{
  STATE_WAITING_FIRST_CHIME,
  STATE_MEASURING
};

enum State state;

//////////////////////////////
// Synchronize current millis with RTC
//////////////////////////////
unsigned long getCurrentMillis()
{
  unsigned long currentMillis = millis();

  if (currentMillis – lastSyncMillis >= SYNC_INTERVAL_MS)
  {
  rtcAtLastSync = rtc.now();
  lastSyncMillis = currentMillis;
  }

  unsigned long elapsedMillis = currentMillis – lastSyncMillis;
  DateTime currentTime = rtcAtLastSync + TimeSpan(elapsedMillis / 1000);
  return (currentTime.unixtime() * 1000) + (elapsedMillis % 1000);
}

/////////////////////////
// Interrupt for counting pendulum oscillations
/////////////////////////
void IRPendulumISR()
{
  if (currentTimeMs – pendulumMs > PENDULUM_DEBOUNCE_MS)
  {
  greenState = true;
  digitalWrite(GREEN_LED, HIGH);
  greenStartMs = currentTimeMs;
  lastPendulumMs = pendulumMs;
  pendulumMs = currentTimeMs;
  pendulumDetected = true;
  }
}

/////////////////////////
// Detection of chime strikes
/////////////////////////
void IRChimeISR()
{
  redState = true;
  digitalWrite(RED_LED, HIGH); // Turn on the red LED
  redStartMs = currentTimeMs;
  if (state == STATE_WAITING_FIRST_CHIME || currentTimeMs – lastChimeMs >= CHIME_DELAY_MS)
  {
  blueState = true;
  digitalWrite(BLUE_LED, HIGH); // Turn on the blue LED
  blueStartMs = currentTimeMs;
  chimeDetected = true;
  }
}

/////////////////////////
// Initialization routine
/////////////////////////
void setup()
{
  // Start the serial port
  Serial.begin(57600);

  // Setup RTC
  lastSyncMillis = millis();
  rtcAtLastSync = rtc.now();

  // Start the I2C interface
  Wire.begin();

  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(IR_PENDULUM_PIN), IRPendulumISR, FALLING);
  attachInterrupt(digitalPinToInterrupt(IR_CHIME_PIN), IRChimeISR, FALLING);

  // LCD init
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);

  if (!rtc.begin())
  {
  lcd.print(« Couldn’t find RTC »);
  exit(0);
  }

  if (rtc.lostPower())
  {
  lcd.print(« RTC lost power, »);
  lcd.setCursor(0, 1);
  lcd.print(« let’s set the time! »);
  rtc.adjust(DateTime(1970, 1, 1, 0, 0, 0));
  delay(2000);
  }

  lcd.print(« Waiting first chime »);
  state = STATE_WAITING_FIRST_CHIME;
}

/////////////////////////
// Main loop
/////////////////////////
void loop()
{
  currentTimeMs = getCurrentMillis();

  if (greenState && currentTimeMs – greenStartMs >= GREEN_DURATION)
  {
  greenState = false;
  digitalWrite(GREEN_LED, LOW);
  }

  if (redState && currentTimeMs – redStartMs >= red_DURATION)
  {
  redState = false;
  digitalWrite(RED_LED, LOW);
  }

  if (blueState && currentTimeMs – blueStartMs >= blue_DURATION)
  {
  blueState = false;
  digitalWrite(BLUE_LED, LOW);
  }

  switch (state)
  {

  case STATE_WAITING_FIRST_CHIME:
  if (chimeDetected)
  {
  chimeDetected = false;
  lastChimeMs = currentTimeMs;
  pendulumOscillations = 0;
  state = STATE_MEASURING;
  }
  break;

  case STATE_MEASURING:

  if (pendulumDetected)
  {
  pendulumDetected = false;
  pendulumOscillations++;
  }

  if (chimeDetected)
  {
  chimeDetected = false;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(currentTimeMs – lastChimeMs);
  lcd.print(« ms »);
  lcd.setCursor(0, 1);
  lcd.print(« R/A: »);
  lcd.print((long) (REFERENCE_CHIME_INTERVAL_MS – (currentTimeMs – lastChimeMs)));
  lcd.print(« ms »);
  lcd.setCursor(0, 2);
  lcd.print(pendulumOscillations);
  lcd.print( » osc. »);
  lcd.setCursor(0, 3);
  lcd.print(« Waiting next chime »);

  // Update the time of the last chime
  lastChimeMs = currentTimeMs;
  pendulumOscillations = 0;
  state = STATE_WAITING_FIRST_CHIME;
  }

  // Display timing
  if (currentTimeMs – lastDisplayUpdateMs >= DISPLAY_UPDATE_INTERVAL_MS)
  {
  lastDisplayUpdateMs = currentTimeMs;
  lcd.clear();
  lcd.setCursor(0, 0);
  if ((currentTimeMs – lastChimeMs >= CHIME_DELAY_MS))
  {
  lcd.print(« Waiting second chime »);
  }
  else
  {
  lcd.setCursor(0, 0);
  lcd.print((currentTimeMs – lastChimeMs < CHIME_DELAY_MS) ? (CHIME_DELAY_MS – (currentTimeMs – lastChimeMs)) / 1000 : 0);
  lcd.print(« s »);
  lcd.setCursor(0, 1);
  lcd.print(« Before second chime »);
  }
  }
  break;
  }
}

Je réponds à vos interrogations
Cadrature

[Torzio]

Je m’amuse avec mon périodemètre. En affinant la distance capteur balancier, j’arrive à une bonne cohérence et régularité de la mesure. De temps en temps, toutefois, j’ai une mesure incohérente. Mais, en quelques minutes, j’ai une indication suffisante de la période du balancier.
Lorsque je trouverai le temps de faire un nouveau capteur en fourche, je suis persuadé que je vais augmenter la qualité des mesure.

Je reste persuadé que la mesure précise d’une vingtaine oscillations permet de bien dégrossir le réglage d’une pendule.

Il faut garder à l’esprit qu’une pendule à une très grande irrégularité de marche, due à l’échappement à repos frottant et encore pire, avec un échappement à recul que perturbe les variations de forces d’armage du ressort moteur, la température etc.
On à donc aucun intérêt à mesurer sur un temps long.

Je me base sur ma modeste expérience. Lorsque je veux ajuster un nouveau balancier ou régler un balancier déréglé, sur une pendule, je chronomètre, avec un chronographe au 1/100 de seconde, 20 oscillations et j’utilise mon tableur. Je fais ainsi, depuis plus de 20 ans, avec succès.

Mon projet de périodemètre m’offrira peut-être un peu plus de confort. Je l’ai fait pour le fun.

@+
JC

[Cadrature]

Je vous assure que mon montage est déjà très confortable.
Il serait simple de l’installer dans une boite et des prises et les deux potences qui vont bien.
Un tel montage (imprimé 3D avec des câbles simples à brancher, un menu pour utilisation, des boutons de réglage en fonction des horloges, etc.) intéresse quelqu’un ?

Bien-sûr on peut l’utiliser pour chronométrer 20 oscillations à la milliseconde près. Afficher les calculs que vous proposez sur le tableur, etc.
Ou mesurer un temps long (12h) automatiquement comme je fais.

Cadrature

[Torzio]

Cadrature,

Votre travail est techniquement remarquable ! Il me semble simplement que de greffer, pendant 12 heures, un appareil sur un mouvement de pendule, n’est pas très pratique. Sur un mouvement de comtoise non plus.

J’ai réalisé mon premier périodemètre, avec l’aide précieuse d’un ami électronicien, il y a 30 ans. Nous en avons péniblement vendu 2 ou 3.

Le mien dort sagement dans un tiroir. J’en parle en bas de la page suivante : https://sulka.fr/bal/
On y voit aussi une méthode simple et efficace pour compter les dents et ailes des mobiles

@+
JC

[Cadrature]

Merci pour cette page !

Vous parliez d’un compteur de spiraux.
Vous pensez qu’il y a une demande ?



L’objet me semble assez accessible à réaliser:
– Au dessus: machine à compter les spiraux classique avec sa potence, sa brucelle, sa base rotative sur ressort, etc.
– Sous la glace: un détecteur à laser infrarouge avec un collimateur et une photocell.
– Dans le socle: l’électronique, un affichage et des boutons.



Il y a un intérêt aujourd’hui pour une telle machine ? Il existe encore des horlogers qui comptent des spiraux ? ;-)



Cadrature

[Torzio]

A mon avis il n’y a pas un grand marché ! Il y a déjà des produits très performants qui existent, comme celui ci :

L’horloger rhabilleur, s’il veut perdre son temps à remplacer un spiral, de temps en temps, va utiliser un outil à compter classique et l’amateur a le porte monnaie en peau de hérisson !

Ce projet peut juste apporter une satisfaction personnelle. Ce qui est aussi enrichissant !

@+
JC

[Auteur]

Messages