Die erste Programmversion fokussiert auf die Uhr des Schlafphasenweckers. So lange der Teensy mit dem Computer verbunden ist und noch kein gültiges DCF77-Signal empfangen wurde, wird die RTC mit dem Zeitsignal des Computers gestellt. Sobald ein gültiges DCF77-Signal vorliegt, wird dieses verwendet, um die RTC zu stellen. Die Zeit seit der letzten erfolgreichen Synchronisation wird berechnet.

Hilfreiche Links:

• Time Library: http://www.pjrc.com/teensy/td_libs_Time.html
• http://playground.arduino.cc/Code/DCF77
• Timestamp Generator: http://www.timestampgenerator.com/1357041600/
• https://arduino-hannover.de/2012/06/14/dcf77-empfanger-mit-arduino-betreiben/

// Bibliotheken einbinden
#include <TimeLib.h>          
#include "DCF77.h"          // Bibliothek für das DCF77-Modul


// Definiert die Pins
#define DCF_PIN 2                  // Connection pin to DCF 77 device
#define DCF_INTERRUPT 2            // Interrupt number associated with pin
#define PIN_LED 13


// Definiert irgendwas mit dem DCF77
DCF77 DCF = DCF77(DCF_PIN, DCF_INTERRUPT, false); 



// Definiert die Variablen
bool DCFTimeFound = false;     // wurde ein gueltiges Signal gefunden

time_t DCFtime = 0;
time_t t = 0;

const unsigned long DefaultTime = 1477958400; // Nov 1 2016 
unsigned long lastDCFsignal;
unsigned long noDCFsignal;
unsigned long currentDCFsignal;


// Definiert die Tracking-Variablen für die IF-Abfragen
unsigned long previousMillisSetRTC = 0;
unsigned long previousMillisSerialPrint = 0;


// Definiert die Intervalle für die IF-Abfragen
int intervalSetRTC = 1000;       // Delay für Holen der Zeit
int intervalSerialPrint = 1000;   // Delay für serielle Ausgabe


void setup()  {
  // Initalisiert die Pins
  pinMode(PIN_LED, OUTPUT);       // On-board LED
  pinMode(DCF_PIN, INPUT_PULLUP); // DFC77-Modul
  
  
  // set the Time library to use Teensy 3.0's RTC to keep time
  setSyncProvider(getTeensy3Time);


  Serial.begin(115200);


  while (!Serial);  // Wait for Arduino Serial Monitor to open
  delay(100);
  if (timeStatus()!= timeSet) {
    Serial.println("Unable to sync with the RTC");
  } else {
    Serial.println("RTC has set the system time");
  }

  
  // Startet die Abfrage des DCF77-Moduls
  DCF.Start();
  Serial.println("Waiting for DCF77 time ... ");
  Serial.println("It will take at least 2 minutes until a first update can be processed.");

}


void loop() {
// Aktuelle Zeit abfragen
  unsigned long currentMillis = millis();


// Stelle die Real Time Clock (RTC) auf die aktuelle Zeit
  if ((unsigned long)(currentMillis - previousMillisSetRTC) >= intervalSetRTC) {

  DCFtime = DCF.getTime();              // Check if new DCF77 time is available

  // Wenn die serielle Schnittstelle verfügbar ist, setze die RTC auf diese Zeit
  if (Serial.available() && DCFtime < DefaultTime) {
    t = processSyncMessage();
    if (t != 0) {
      Teensy3Clock.set(t);             // set the RTC
      setTime(t);
    }
  }

  // Wenn ein Zeitsignal vom DCF77-Modul verfügbar ist, setze die RTC auf diese Zeit
  if (DCFtime > DefaultTime) {
    t = DCFtime;
    Serial.println("RTC has been updated to DCF77 time");
    Teensy3Clock.set(t);               // set the RTC
    setTime(t);
    DCFTimeFound = true;
    digitalWrite(PIN_LED, HIGH);
    currentDCFsignal = millis();
  }

  // Berechne die Zeit (in Sekunden) die seit dem Empfang des letzten gültigen DCF-Signals vergangen ist
  if (DCFTimeFound == false) {
    noDCFsignal = millis() /1000;
  }
  else {
    lastDCFsignal = (millis() - currentDCFsignal) / 1000;
  }

  //Speichere die aktuelle Zeit in die zughörige Variable
  previousMillisSetRTC = currentMillis;
  }


// Stetze die RTC auf die Zeit der seriellen Schnittstelle
  if ((unsigned long)(currentMillis - previousMillisSerialPrint) >= intervalSerialPrint) {
    
    // Gibt die aktuelle Zeit aus
    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
    Serial.print(" ");
    Serial.print(day());
    Serial.print(" ");
    Serial.print(month());
    Serial.print(" ");
    Serial.print(year());
    printDCFsyncTime();
    Serial.println();

  //Speichere die aktuelle Zeit in die zughörige Variable
  previousMillisSerialPrint = currentMillis;
  }

}


time_t getTeensy3Time()
{
  return Teensy3Clock.get();
}


/*  code to process time sync messages from the serial port   */
#define TIME_HEADER  "T"   // Header tag for serial time sync message

unsigned long processSyncMessage() {
  unsigned long pctime = 0L;

  if(Serial.find(TIME_HEADER)) {
     pctime = Serial.parseInt();
     return pctime;
     if( pctime < DefaultTime) { // check the value is a valid time (greater than Nov 1 2016)
       pctime = 0L; // return 0 to indicate that the time is not valid
     }
  }
  return pctime;
}


void printDigits(int digits) {
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
}


void printDCFsyncTime() {
  if (DCFTimeFound == false){
    Serial.print(" no DCF77 sync since ");
    Serial.print(noDCFsignal);
    Serial.print(" sec.");
  }
  else {
    Serial.print(" last DCF77 sync ");
    Serial.print(lastDCFsignal);
    Serial.print(" sec. ago");
  }
}

Der Sketch verwendet 29.104 Bytes (2%) des Programmspeicherplatzes. Das Maximum sind 1.048.576 Bytes. Globale Variablen verwenden 5.896 Bytes (2%) des dynamischen Speichers, 256.248 Bytes für lokale Variablen verbleiben. Das Maximum sind 262.144 Bytes.

Tags: #Arduino # Schlafphasenwecker