■音をひろう

まずは、マイクで時計の音をひろって電気信号に変換しないと始まりません。
そこで、圧電スピーカーをマイク代わりに利用しようと思います。
直径20mmの圧電スピーカーです。

このように、セラミック部分に直接はんだ付けしようとすると蒸着された銀の部分がはんだに食われます。
この手の物を付ける時には銀入りはんだを使うと良いのでしょうが持ってませんので、 そういう時には半田ごてを350度に設定し、銅線に事前にはんだメッキをしておいて銀の部分にのせてから上からチョットだけ半田ごてを当ててくっつけます。

銅線が乗ってるだけに見えますが、これで銀の部分に付いています。
ちなみに私がマイクとして今回使用したのは、

■LEDを点滅させる

増幅された音をもう一つのオペアンプに接続して、基準電圧と比較して音のピークの時だけLEDを点滅させられるようにしてみます。
赤い部分が前回の回路図から変更した所です。


可変抵抗を微妙な感じで操作すると、音のピークの箇所でLEDが点灯するようにできました。
ただ、LEDが点灯するとノイズが乗るのが残念です。

LEDの箇所にオシロスコープを取り付けると、なんだか動きそうではあります。

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, FALLING);
}
void loop () {
  digitalWrite(LED_BUILTIN, digitalRead(2));
}
unsigned long t;
void func_() {
  noInterrupts();
  unsigned long l;
  l = micros();
  Serial.println(l - t);
  t = l;
  interrupts();
}

■タイミングを取得する

チクタク音を電気信号に変換しても、スパッとON/OFFせずに、激しいチャタリングが起きていると同様の状態だと思います。
そこで、信号が変化後の50ミリ秒(50000μ秒)以内を無視することにしてチャタリングを取りたいと思います。

unsigned long t_cur, t_old;
bool flag;

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, CHANGE);
}

void loop () {
  if (flag) {
    Serial.print(round((double)1000000 / (t_cur - t_old)));
    Serial.print(" : ");
    Serial.println(t_cur - t_old);
    flag = 0;
  }
}

void func_() {
  noInterrupts();
  unsigned long i;
  i = micros();
  if ((i - t_cur) > 50000) {
    flag = 1;
    t_old = t_cur;
    t_cur = i;

    static bool f;
    digitalWrite(LED_BUILTIN, f = !f);
  }
  interrupts();
}

赤文字部分は、取得した時間を1秒(1000000μ秒)で割り振動数を計算しています。
このプログラムを実行すると、このようになりました。

とりあえず、振動数とタイミングは取得できているみたいです。
この時代の時計は振動数：18000回/h（5振動、2.5Hz）らしいので大体近い値が出てはいるみたいです。

■日差を計算する

古い懐中時計の日差を求めようとしていましたが、あまりに周期のバラつきが大きくてテストには向きませんでした。
そこで、他の機械式時計、6振動を用意しました。
実験として6振動の日差を求めるために、上のプログラムのloop関数内を修正しました。
プログラム中の赤文字の6の部分で6振動を決め打ちしています。

unsigned long t_cur, t_old;
bool flag;

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, CHANGE);
}

int cycle;
unsigned long sec_old;
void loop () {
  if (flag) {
    Serial.print(round((double)1000000 / (t_cur - t_old)));
    Serial.print(" : ");
    Serial.println(t_cur - t_old);
    
    if (++cycle == (6 * 2)) {
      long pos = (1000000 * 2) - (t_cur - sec_old);
      Serial.println((double)pos * 30 * 60 * 24 / 1000000);
      sec_old = t_cur;
      cycle = 0;
    }
    flag = 0;
  }
}

void func_() {
  noInterrupts();
  unsigned long i;
  i = micros();
  if ((i - t_cur) > 50000) {
    flag = 1;
    t_old = t_cur;
    t_cur = i;

    static bool f;
    digitalWrite(LED_BUILTIN, f = !f);
  }
  interrupts();
}

上記プログラムでは、6振動×２で2秒間の電気信号を取得して、Arduinoのタイマーと比較することにより、日差を求めています。
実行するとこのようになりました。

音のない静かな環境で微妙な調整をすると、ある程度は日差が取得できるみたいですが、周囲のわずかな音(赤枠の範囲)によって誤差が発生してしまいます。
現状では、回路が発振してしまい、調整が非常に微妙で静かな環境が必要です。
これでは、まともに使用できる物ではありません。

■プログラムを改良する

今までのテストプログラムを参考として、それらしいプログラムを作成します。
まず、10個のデータ構造を用意して割り込みで順次取得した値を格納することにしました。
今回値と前回値を比較して振動数を計算します。
振動数によりデータ構造から必要な値を取り出して一日あたりの誤差を計算することにしました。

bool update_flag;

unsigned long ar[10];
unsigned int ar_pt;

void push(unsigned long val) {
  ar_pt++;
  if (ar_pt == 10) ar_pt = 0;
  ar[ar_pt] = val;
}

unsigned long pop() {
  return ar[ar_pt];
}

unsigned long pop_old(int gen) {
  int pos;
  pos = (int)ar_pt - gen;
  if (pos < 0) pos = 10 + pos;
  return ar[pos];
}

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, CHANGE);
}

unsigned long sec_old;
void loop () {
  if (update_flag) {
    unsigned int cycle = round((double)1000000 / (pop() - pop_old(1)));
    //1秒あたりの誤差をマイクロ秒でもとめる
    long micro_sec = 1000000 - (pop() - pop_old(cycle));
    //一日当たりの誤差をもとめる
    double _day = (double)(micro_sec * 60 * 60 * 24) / (double)1000000;

    Serial.print(cycle);
    Serial.print("振動　一日あたりの誤差 ");
    Serial.print(_day);
    Serial.println(" 秒");
    update_flag = false;
  }
}

void func_() {
  noInterrupts();
  unsigned long i;
  i = micros();
  if ((i - pop()) > 50000) {
    push(i);
    update_flag = true;
    static bool f;
    digitalWrite(LED_BUILTIN, f = !f);
  }
  interrupts();
}

このプログラムだと、起動1秒後にデータが揃うととりあえずそれらしい値を表示します。
正しいのか不明ですが、いつも進む6振動の時計を測定した結果です。
測定前にゼンマイをいっぱいに巻いておきました。
このまま24時間時計を放置し電波時計と比較した結果、実際には90秒進みました。


いつも遅れる8振動の時計も測定してみました。
測定前にゼンマイをいっぱいに巻いておきました。
このまま24時間時計を放置し電波時計と比較した結果、実際には24秒遅れました。

確認する方法が無いのでわかりませんが、それらしい値が出ています。

PWMによる疑似アナログ出力 で調べた方法を使い、オペアンプの比較回路に与える基準電圧をソフトウエアでコントロールできるようにしてみたいと思います。
まずは、回路を改良しました。

基準電圧を作り出す可変抵抗を取り外して、赤色部分が新たに追加した回路です。　
Arduinoのデジタルピン3を使用してアナログ出力をしたいと思います。
追加した抵抗とコンデンサはローパスフィルタでPWMの高周波成分をならしてノイズがなるべく入らないようにしています。
フォトカプラは、Arduinoの電源ノイズを避けるために入れています。

試しに次のように接続して確認してみます。

bool update_flag;

unsigned long ar[10];
unsigned int ar_pt;

void push(unsigned long val) {
  ar_pt++;
  if (ar_pt == 10) ar_pt = 0;
  ar[ar_pt] = val;
}

unsigned long pop() {
  return ar[ar_pt];
}

unsigned long pop_old(int gen) {
  int pos;
  pos = (int)ar_pt - gen;
  if (pos < 0) pos = 10 + pos;
  return ar[pos];
}

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, CHANGE);
}

unsigned long sec_old;
void loop () {
  if (update_flag) {
    unsigned int cycle = round((double)1000000 / (pop() - pop_old(1)));
    //1秒あたりの誤差をマイクロ秒でもとめる
    long micro_sec = 1000000 - (pop_old(0) - pop_old(cycle));
    //前回の1秒あたりの誤差をマイクロ秒でもとめる
    long micro_sec_old = 1000000 - (pop_old(1) - pop_old(cycle + 1));

    Serial.print(cycle);
    Serial.print(" 振動\t日差 ");

    //1サイクルずらした測定結果を合計して2で割る　テンプの片振り対策
    Serial.print(round((micro_sec + micro_sec_old) / 2 / 11.57));

    Serial.print(" sec/day\t\t 片振り ");
    //前回のテンプの1サイクルと今回のテンプの1サイクルの時間を引いて、片振りの時間をもとめる /1000をしてマイクロ秒をミリ秒にする
    long be = abs(((signed long)pop_old(0) - (signed long)pop_old(1)) - ((signed long)pop_old(1) - (signed long)pop_old(2)));
    Serial.print((double)be / 1000);
    Serial.println(" ms");

    update_flag = false;
  }
}

void func_() {
  noInterrupts();
  unsigned long i;
  i = micros();
  if ((i - pop()) > 50000) {
    push(i);
    update_flag = true;
    static bool f;
    digitalWrite(LED_BUILTIN, f = !f);
  }
  interrupts();
}

volatile unsigned long t;

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, CHANGE);
}

long count;
long aver;

void loop () {
  static unsigned long pos_old;

  if (t) {
    if (!pos_old) {
      pos_old = t;
      t = 0;
      return;
    }
    long pos = 1000000 - (long)(t - pos_old); //1秒の誤差をマイクロ秒でもとめる
    pos = (pos * 24 * 60 * 60) / 1000000; //日差を秒でもとめる
    Serial.print(pos);
    aver += pos;
    count++;
    Serial.print("\taverage count = ");
    Serial.print(count);
    Serial.print("\trate(sec/day) = ");
    Serial.print(aver / count);
    pos_old = t;
    t = 0;
    Serial.println();
  }
}

void func_() {
  noInterrupts();
  unsigned long i;
  static unsigned long old;
  i = micros();
  if ((i - old) > 900000) {//900ms以内を誤動作とする
    old = i;
    t = i;
    //ボード上のLEDをチカチカさせる
    static bool f;
    digitalWrite(LED_BUILTIN, f = !f);
  }
  interrupts();
}

//Arduinoに搭載されている発信器の一日あたりの誤差(秒)
#define OSC_RATE_SEC -20
#define BUFF_SIZE 21
#define NUM_MEASURE 9

unsigned long ar[BUFF_SIZE];
unsigned int ar_pt;

void push(unsigned long val) {
  ar[ar_pt] = val;
  ar_pt++;
}

unsigned long pop(unsigned int index) {
  return ar[index];
}

void reset_buff() {
  for (int i = 0; i < BUFF_SIZE; i++) {
    ar[i] = 0;
  }
  ar_pt = 0;
}

bool empty() {
  //1秒プラス1回の値が取得できたら一杯になったとする
  if (ar_pt > 1) {
    if (1000000 < (unsigned long)(pop(ar_pt - 1) - pop(1))) {
      return false;
    }
  }
  if (ar_pt < BUFF_SIZE) {
    return true;
  }
  return false;
}

void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), func_, CHANGE);
}

long count;
long aver;
int cycle_old;
long rate_old;
int rate_count;
unsigned long sec_old;
int err_count;

void loop () {
  if (!empty()) {
    //****振動数を計算****
    unsigned long old_pos1 = 0, old_pos2 = 0;
    unsigned int cycle = 0;
    for (cycle = 0; cycle < BUFF_SIZE; cycle++) {
      //各サイクル毎の1秒に対する差を計算する
      unsigned long pos = abs(1000000 - (long)(pop(cycle) - pop(0)));
      if (old_pos1 > old_pos2 && old_pos2 < pos) {
        //old_pos2が一番差が少なく、振動数であると考えられる
        break;
      }
      old_pos1 = old_pos2;
      old_pos2 = pos;
    }
    cycle--;
    Serial.print(" ");
    Serial.print(cycle);
    Serial.print(" 振動");
    //****歩度を計算****
    //----1秒の誤差をもとめる----
    //1秒の誤差をマイクロ秒でもとめる
    long meas1 =  pop(cycle) - pop(0) - 1000000;
    //1日の誤差をマイクロ秒でもとめる
    long err_meas1 = 86400 * meas1;
    //1日の誤差を秒に変換する
    long err_meas_sec1 = err_meas1 / -1000000;

    //----1サイクルずらして1秒の誤差をもとめる----
    //1秒の誤差をマイクロ秒でもとめる
    long meas2 =  pop(cycle + 1) - pop(1) - 1000000;
    //1日の誤差をマイクロ秒でもとめる
    long err_meas2 = 86400 * meas2;
    //1日の誤差を秒に変換する
    long err_meas_sec2 = err_meas2 / -1000000;

    //テンプの片振り対策の為に1サイクルずらしたのと平均をとる
    long err_meas_sec = (err_meas_sec1 + err_meas_sec2 ) / 2;

    Serial.print("\t\t 歩度 ");
    //Arduino自体の歩度を引き算する
    int i = err_meas_sec - OSC_RATE_SEC;
    Serial.print(i);
    Serial.print("秒");
    if (count == 1) {//最初に取得した値との差が100以上の場合にはリセット
      if (abs(aver - i) > 100) {
        reset();
      }
    }
    int pos = aver / count;
    if (count < 2 || abs(pos - i) < 100) { //歩度が平均より100秒以上の場合にはエラーとする
      err_count = 0;
      if (cycle == cycle_old) {
        aver += i;
        count++;
        Serial.print("\taverage count = ");
        Serial.print(count);
        Serial.print("\trate(sec/day) = ");
        long rate = aver / count;

        Serial.print(rate);
        if (rate == rate_old) {
          rate_count++;
        } else {
          rate_count = 0;
          rate_old = rate;
        }
        if (rate_count > NUM_MEASURE) {
          Serial.print("\n測定終了\n");
          while (1);
        }
      } else {
        cycle_old = cycle;
        reset();
      }
    } else {
      err_count++;
      if (err_count > NUM_MEASURE) {
        reset();
      }
      Serial.print(" ERROR");
    }
    //****片振りを計算****
    //前回のテンプの1サイクルと今回のテンプの1サイクルの時間を引いて、片振りの時間をもとめる /1000をしてマイクロ秒をミリ秒にする
    long be = abs((long)(pop(1) - pop(0)) - (long)(pop(2) - pop(1)));
    Serial.print("\t\t 片振り ");
    Serial.print((double)be / 1000);
    Serial.println("ミリ秒");

    reset_buff();
  }
}

void reset() {
  count = 0;
  aver = 0;
  rate_old = 0;
  rate_count = 0;
  reset_buff();
}

void func_() {
  noInterrupts();
  if (empty()) {
    unsigned long i;
    static unsigned long old;
    i = micros();
    if ((i - old) > 50000) {
      old = i;
      push(i);
      //ボード上のLEDをチカチカさせる
      static bool f;
      digitalWrite(LED_BUILTIN, f = !f);
    }
  }
  interrupts();
}

//Arduinoに搭載されている発信器の一日あたりの誤差(秒)
#define OSC_RATE_SEC -20
#define PSEC_COUNT 5
const unsigned long PSEC[] = {1000000 - (1000000 * 0.0138), 2000000 - (2000000 * 0.0138), 3000000 - (3000000 * 0.0138), 4000000 - (4000000 * 0.0138), 5000000 - (5000000 * 0.0138)};
const unsigned long RSEC[] = {1000000 + (1000000 * 0.0138), 2000000 + (2000000 * 0.0138), 3000000 + (3000000 * 0.0138), 4000000 + (4000000 * 0.0138), 5000000 + (5000000 * 0.0138)};
unsigned long contains_time;

void setup () {
  //delay(1000);
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), _int, CHANGE);
}

int measure(unsigned long*time, int*count) {
  static unsigned long cur;
  static int counter;
  if (!cur) {
    cur = contains_time;
  }
  *time = contains_time - cur;
  for (int i = 0; i < PSEC_COUNT; i++) {
    if (PSEC[i] < *time && RSEC[i] > *time) {
      *count = (counter * 10) / (i + 1);
      *time = *time / (i + 1);
      cur = 0;
      counter = 0;
      return 1;
    }
  }
  counter++;
  if (RSEC[PSEC_COUNT - 1] < *time) {
    cur = 0;
    counter = 0;
  }
  return 0;
}

void loop () {
  if (contains_time) {
    unsigned long time;
    int count;
    if (measure(&time, &count)) {
      float f = count;
      f = f / 10;
      Serial.print(f);
      Serial.print("振動 : 歩度");

      long pos;
      //1秒の誤差をマイクロ秒でもとめる
      pos = (long)time - 1000000;
      //1日の誤差をマイクロ秒でもとめる
      pos = pos * 86400;
      //1日の誤差を秒に変換する
      pos = pos / -1000000;
      //Arduino自体の歩度を引き算する
      pos = pos - OSC_RATE_SEC;
      Serial.print(pos);
      Serial.print("秒");

      //歩度の平均を取りシリアルモニタに結果を出力する
      static int avr_count;
      static int avr;
      static int avr_error;
      static int old_count;
      if (old_count != count) {
        old_count = count;
        avr_count = 0;
        avr = 0;
        avr_error = 0;
      }

      if (avr_count == 0 || avr_error > 2) {//平均エラーが3回続いたら初期化する
        avr_count = 1;
        avr = pos;
        Serial.println(" 平均初期化");
        avr_error = 0;
      } else {
        if (abs((avr / avr_count) - pos) < 100) {//歩度が平均より100秒以上の場合にはエラーとする
          avr_count++;
          avr += pos;
          Serial.print(" 平均カウンタ");
          Serial.print(avr_count);
          Serial.print("回 平均歩度");
          Serial.print(avr / avr_count);
          Serial.println("秒");
          avr_error = 0;
        } else {
          Serial.println(" 平均エラー");
          avr_error++;
        }
      }
    }
    contains_time = 0;
  }
}

void _int() {
  noInterrupts();
  unsigned long i;
  static unsigned long old;
  i = micros();
  if ((i - old) > 50000) {
    old = i;
    contains_time = i;
    //ボード上のLEDをチカチカさせる
    static bool f;
    digitalWrite(LED_BUILTIN, f = !f);
  }
  interrupts();
}