DCF77 und getTime() <- ich raff es nicht

Hallo zusammen,

ich kämpfe mal wieder mit DCF. Die Zeitmessung klappt sehr gut, so dass ich immer nach 3 Minuten das Zeitsignal bekomme. Was aber aus irgendeinen Grund nicht funktioniert, ist die Methode getTime() in der Loop. Der Return-Wert ist und bleibt immer “0”, auch nach über 30 Minuten. Das bedeutet, dass der Buffer in dem die Empfangen Daten geschrieben werden immer ungültig ist. Aber die erste Synchronisation mit dem DCF Empfänger funktioniert immer beim ersten Mal, die ja auch nur die getTime() Funktion aufruft.
Hier der Code, damit es etwas klarer wird:

#include <SPI.h>
#include <LiquidCrystal.h>
#include <LedControl.h>
#include <Utils.h>
#include <DCF77.h>
#include <Wire.h>
#include <DS3232RTC.h>
#include <Time.h>
#include <MsTimer2.h>
#include <LEDDriver.h>
#include <Variables.h>
#include <LCDMenu.h>

#define DEBUG

#ifdef DEBUG
#include <Streaming.h>
#endif // DEBUG


DCF77 DCF = DCF77(filtered_dcf77_pin, 0);
LCDMenu LCD = LCDMenu(9, 8, 6, 5, 4, 3);
/*
pin 12: DataIn
pin 11: CLK
pin 10: LOAD
*/
LEDDriver LED = LEDDriver(12, 11, 10, 1);


void low_pass_filter()
{
	// http://en.wikipedia.org/wiki/Low-pass_filter#Continuous-time_low-pass_filters

	//fixed point arithmetics with 5 decimals
	const uint16_t decimal_offset = 10000;
	static uint32_t smoothed = 0 * decimal_offset;

	//const uint32_t input = digitalRead(dcf77_sample_pin) * decimal_offset;
	const uint32_t input = analogRead(dcf77_analog_sample_pin) > 200 ? decimal_offset : 0;

	// compute N such that the smoothed signal will always reach 50% of
	// the input after at most 50 samples (=50ms).
	// N = 1 / (1- 2^-(1/50)) = 72.635907286
	const uint16_t N = 72;
	smoothed = ((N - 1) * smoothed + input) / N;

	// introduce some hysteresis
	static uint8_t square_wave_output = 0;

	if ((square_wave_output == 0) == (smoothed >= decimal_offset / 2)) {
		// smoothed value more >= 50% away from output
		// ==> switch output
		square_wave_output = 1 - square_wave_output;
		// ==> max the smoothed value in order to introduce some
		//     hysteresis, this also ensures that there is no
		//     "infinite memory"
		smoothed = square_wave_output ? decimal_offset : 0;
	}

	digitalWrite(filtered_dcf77_pin, square_wave_output);
}


unsigned long getDCFTime()
{
	return DCF.getTime();
}


void setup()
{
	LED.shutdown(0, false);
	/* Set the brightness to a medium values */
	LED.setIntensity(0, 15);
	/* and clear the display */
	LED.clearDisplay(0);

	pinMode(dcf77_sample_pin, INPUT);
	digitalWrite(dcf77_sample_pin, HIGH);
	pinMode(filtered_dcf77_pin, OUTPUT);

	MsTimer2::set(1, low_pass_filter);
	MsTimer2::start();

	DCF.Start();
	setSyncInterval(600); //synchronization every 10 mins

	#ifdef DEBUG
		setSyncProvider(DCF.getTime);
	#else
		setSyncProvider(RTC.get);
	#endif // DEBUG

	LCD.begin(8, 2);
	LCD.clear();

	pinMode(PushButton, INPUT_PULLUP);

	#ifdef DEBUG
		Serial.begin(115200);
		diagnosis();
	#endif // DEBUG
}


void loop()
{
	static unsigned long PressButtonTimer;
	static byte MenuLevel;
	if (digitalRead(PushButton))
	{		
		if ((millis() - PressButtonTimer) > DEBOUNCE)
		{
			PressButtonTimer = millis();
			MenuLevel++;
			if (MenuLevel > 2)
			{
				MenuLevel = 0;
				LCD.SetUpdateDate(true);
				LCD.SetUpdateTemp(true);
				LCD.SetUpdateTime(true);
			}
		}
	}
	
	static time_t prevTimeSyncToLEDs;
	if (prevTimeSyncToLEDs != now()) //now() returns seconds beginning from 1970
	{
		prevTimeSyncToLEDs = now();

		const unsigned long DCFTime = getDCFTime();
		Serial << DCFTime << endl;
		if (DCFTime != 0) //check if new DCF77 time is available
		{
			setTime(DCFTime);
			RTC.set(DCFTime);
		}

		tmElements_t tm;
		breakTime(prevTimeSyncToLEDs, tm);

		LED.WriteTimeToLEDMatrix(tm, "seconds");
		LED.WriteTimeToLEDMatrix(tm, "minutes");
		LED.WriteTimeToLEDMatrix(tm, "hours");

		LCD.ShowMenu(MenuLevel, tm, RTC.temperature() / 4.);
	}
}


#ifdef DEBUG
void diagnosis()
{
	Serial.println("Waiting for DCF77 time ... ");

	int rising_edge = 0;
	int falling_edge = 0;
	int previous_rising_edge;
	bool was_high = false;

	while (timeStatus() == timeNotSet)
	{
		const uint8_t sensor_value = digitalRead(filtered_dcf77_pin);
		if (sensor_value) {
			if (!was_high) {
				rising_edge = millis();
				was_high = true;
			}
		}
		else {
			if (was_high) {
				falling_edge = millis();
				Serial.print("Cycle, Pulse: ");

				const int cycle = rising_edge - previous_rising_edge;
				if (cycle < 1000) {
					Serial.print(' ');
				}
				Serial.print(cycle);
				Serial.print(',');
				Serial.print(' ');

				const int pulse = falling_edge - rising_edge;
				if (pulse < 100) {
					Serial.print(' ');
				}
				Serial.print(pulse);
				previous_rising_edge = rising_edge;
				was_high = false;

				Serial.print(' ');
				Serial.print(pulse < 180 ? '.' : 'X');

				Serial.print(' ');
				Serial.print(cycle <1800 ? ' ' : 'm');

				Serial.println();
			}
		}
	}

	Serial.println();

	//DCF.initialize();

}
#endif // DEBUG

Ich habe auch schon die initialize() Methode von der DCF lib als public definiert und diese nach der Synchronisation aufgerufen, damit der Buffer gelöscht wird. Hat aber auch nix gebracht.

Habt ihr eine Idee, warum die Synchrionisation anfangs klappt (im Debug Mode), aber dann während der Programmlaufzeit geTime() immer 0 zurückgibt?
In den Beispielen der DCF Lib sieht es nicht anders aus.