====== Schlafphasenwecker - Programmversion 0.1 ======
<box 30% green right|**Achtung**>Dies ist eine alte Programmversion.</box>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/

Bekannte Probleme:
  * Beim Aufspielen eines neuen Sketches wird nicht immer die Zeit synchronisiert.
  * Es ist außerdem nicht sinnvoll, dass auf den seriellen Monitor gewartet wird. Perspektivisch wird der Wecker ohne Verbindung zum Computer betrieben.
  * Manchmal scheint das DCF-Modul kein verwertbares Signal auszugeben. Wenn man ihn dann bewegt, an den Käbelchen wackelt, mit dem FInger über die Bauteile schreicht, geht er dann wieder. Ich muss noch herausfinden, wo das Problem liegt. Mit dem Programm //DCFSignal// kann man an der seriellen Schnittstelle das Ausgangssignal des DCF-Moduls beobachten.

<code>
// 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");
  }
}
</code>

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.

{{tag>Arduino Schlafphasenwecker Teensy}}