DCF77-Programm-Multitaskingproblem

[Oliver G. (suchoi31)]

Guten Tag,

Vorab:
Microcontroller:Atmega32
Frequenz:16MHz
DCF-Modul:Conrad
Entwicklungsumgebung:AVR-Studio 4.18 Build 684
WinAVR_20100110
STK 500



ich habe das Dekodierprogramm von Johannes M. etwas modifiziert und habe 
mich gewundert, warum ich nicht parallel mehere Operationen gleichzeitig 
ausführen kann, ohne das der DCF-Empfang beeinflusst wird.

Wenn ich nun etwas in die while-Schleife der main Funktion 
hineinschreibe, beispielsweise ein Temperaturauswertprogramm oder ein 
Programm das einen weckt, kommt der Dekodiervorgang des DCF-Signals 
sofort durcheinander und er findet nicht mehr den Beginn einer neuen 
Minute. Auch wenn komplett ohne Delays gearbeitet wird.

Kann mir Jemand sagen woran das liegen könnte?

Hier der Programmcode zur Überprüfung.

//DCF-Uhr mit LCD20x4
//ATmega16 @ 16 MHz
//Autor: Johannes Maslowski
//Version 2010-02-28-00-11
//AVR-Studio 4.18 Build 692, WinAVR 20100110

//Header Dateien
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include "lcd-routines.h"

/////////////
//Variablen//
/////////////
//date
unsigned char week_day;
unsigned char day;
unsigned char month;
unsigned int  year;

//time
unsigned int  hundertstelsecond;
unsigned char second;
unsigned char minute;
unsigned char hour;
unsigned char timezone;

//Weckzeit
unsigned char alarm_stunde=17;
unsigned char alarm_minute=20;

//Temperatur
int temperatur;

//Speicherbereich für DCF-Pegel
unsigned char dataPC;

//Pegel-Auswertung
unsigned int counter_high;
unsigned int counter_low;
unsigned char bit_number;

//dcf_date
unsigned char dcf_week_day;
unsigned char dcf_day;
unsigned char dcf_month;
unsigned char dcf_year;
unsigned char dcf_date_parity;

//dcf_time
unsigned char dcf_second;
unsigned char dcf_minute;
unsigned char dcf_minute_parity;
unsigned char dcf_hour;
unsigned char dcf_hour_parity;
unsigned char dcf_timezone;

//Puffer für die int --> char Umwandlung
char itoa_buffer[8];

//Array für die DCF-Datenbits
//uint8_t minute_frame[60];  //wird noch nicht genutzt

//Schaltjahr
unsigned char leapyear;

////////////////////
//Reset-Funktionen//
////////////////////
void counter_reset(void)
{
  counter_high=0;
  counter_low=0;
  bit_number=0;
}

void dcf_date_reset(void)
{
  dcf_week_day=0;
  dcf_day=0;
  dcf_month=0;
  dcf_year=0;
  dcf_date_parity=0;
}

void dcf_time_reset(void)
{
  dcf_minute=0;
  dcf_minute_parity=0;
  dcf_hour=0;
  dcf_hour_parity=0;
  dcf_timezone=0;
}

/////////////
//Sonstiges//
/////////////
//Eine führende 0 ergänzen bei Zahlen kleiner/gleich 9
void leading_0(unsigned char digit)
{
  if(digit<=9)
  {
    lcd_data('0');
  }
}

/////////////////
//LCD-Ausgaben///
/////////////////

//Intelligy Schriftzug
void show_intelligy_string(unsigned char column,unsigned char row) //Übergabe der Cursorposition (Spalte,Zeile)
{
    set_cursor(column,row);

  lcd_string("Intelligy Clock");
}

//Zusammengeführte Zeit
void show_matched_time(unsigned char column,unsigned char row)  //Übergabe der Cursorposition (Spalte,Zeile)
{
  set_cursor(column,row);

  //LCD-Ausgabe: Stunde
  leading_0(hour);
  itoa(hour,itoa_buffer,10);
  lcd_string(itoa_buffer);
  lcd_data(':');

  //LCD-Ausgabe: Minute
  leading_0(minute);
   itoa(minute,itoa_buffer,10);
  lcd_string(itoa_buffer);
  lcd_data(':');

  //LCD-Ausgabe: Sekunde
  leading_0(second);
   itoa(second,itoa_buffer,10);
  lcd_string(itoa_buffer);
//  lcd_data(' ');

}

//Zusammengeführtes Datum
void show_matched_date(unsigned char column,unsigned char row)  //Übergabe der Cursorposition (Spalte,Zeile)
{
  set_cursor(column,row);

  //LCD-Ausgabe: Wochentag
  switch(week_day)
  {
    case 1: lcd_string("Mo,  ");break;  //LCD-Ausgabe: Montag
    case 2: lcd_string("Di,  ");break;  //LCD-Ausgabe: Dienstag
    case 3: lcd_string("Mi,  ");break;  //LCD-Ausgabe: Mittwoch
    case 4: lcd_string("Do,  ");break;  //LCD-Ausgabe: Donnerstag
    case 5: lcd_string("Fr,  ");break;  //LCD-Ausgabe: Freitag
    case 6: lcd_string("Sa,  ");break;  //LCD-Ausgabe: Samstag
    case 7: lcd_string("So,  ");break;  //LCD-Ausgabe: Sonntag
    default:lcd_string("     ");break;
  }
  
  //LCD-Ausgabe: Tag
  leading_0(day);
  itoa(day,itoa_buffer,10);
  lcd_string(itoa_buffer);
  lcd_data('.');

  //LCD-Ausgabe: Monat
  leading_0(month);
   itoa(month,itoa_buffer,10);
  lcd_string(itoa_buffer);
  lcd_string(".");

  //LCD-Ausgabe: Jahreszahl
  leading_0(year);
   itoa(year,itoa_buffer,10);
  lcd_string(itoa_buffer);
}

//Weckzeit
void show_weckzeit(unsigned char column,unsigned char row)//Übergabe der Cursorposition (Spalte,Zeile)
{

set_cursor(column,row);

 
 lcd_string("Weckzeit: ");
 
 //LCD Ausgabe Weckstunde

 leading_0(alarm_stunde);
 itoa(alarm_stunde,itoa_buffer,10);
 lcd_string(itoa_buffer);
 lcd_string(":");

 //LCD Ausgabe Weckminute

 leading_0(alarm_minute);
 itoa(alarm_minute,itoa_buffer,10);
 lcd_string(itoa_buffer);



}


//Temperatur
void show_temperatur(unsigned char column,unsigned char row)//Übergabe der Cursorposition (Spalte,Zeile)
{

set_cursor(column,row);

 //LCD Ausgabe Temperatur

 itoa(temperatur,itoa_buffer,10);
 lcd_string(itoa_buffer);
 
 lcd_string("°C");
}

///////////////////////////
//DCF-Synchronisation/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//High-Pegel muß für 1700-1900ms anliegen
//Danach muß ein Low-Pegel folgen
void dcf_sync(void)
{
  show_matched_date(0,3);
  show_matched_time(6,2);
  show_weckzeit(0,4);
  show_temperatur(17,4);

  //LCD-Ausgabe: Synchronisation läuft gerade
  set_cursor(19,1);
  lcd_data('?');

  if(!(dataPC & (1<<PINC1)))
  {
    if(counter_high>=175 && counter_high<=195)
    {
      //LCD-Ausgabe: Synchronisation erfolgreich
      set_cursor(19,1);
      lcd_data('!');

      counter_reset();
      dcf_date_reset();
      dcf_time_reset();
    }
    else
    {
      counter_high=0;
      dcf_sync();
    }
  }
  else
  {
    dcf_sync();
  }
}

//////////////////
//DCF-Auswertung//
//////////////////
void dcf_0(void)
{
  switch(bit_number)
  {
    case 0: ;break;  //Start einer neuen Minuten, muß immer 0 sein
    case 1: ;break;  //Wetterdaten
    case 2: ;break;  //Wetterdaten
    case 3: ;break;  //Wetterdaten
    case 4: ;break;  //Wetterdaten
    case 5: ;break;  //Wetterdaten
    case 6: ;break;  //Wetterdaten
    case 7: ;break;  //Wetterdaten
    case 8: ;break;  //Wetterdaten
    case 9: ;break;  //Wetterdaten
    case 10: ;break;  //Wetterdaten
    case 11: ;break;  //Wetterdaten
    case 12: ;break;  //Wetterdaten
    case 13: ;break;  //Wetterdaten
    case 14: ;break;  //Wetterdaten
    case 15: ;break;  //Rufbit für PTB
    case 16: ;break; //Keine Änderung der Zeitzone
    case 17: ;break;  //Zeitzone: dcf_timezone=dcf_timezone
    case 18: dcf_timezone+=1;break;  //Zeitzone: 
    case 19: ;break;  //keine Schaltsekunde
    case 20: dcf_sync();break;  //Beginn der Zeitinformation (immer 1)
    case 21: ;break;
    case 22: ;break;
    case 23: ;break;
    case 24: ;break;
    case 25: ;break;
    case 26: ;break;
    case 27: ;break;
    case 28: ;break;  //Parität: Minute
    case 29: ;break;
    case 30: ;break;
    case 31: ;break;
    case 32: ;break;
    case 33: ;break;
    case 34: ;break;
    case 35: ;break;  //Parität: Stunde
    case 36: ;break;
    case 37: ;break;
    case 38: ;break;
    case 39: ;break;
    case 40: ;break;
    case 41: ;break;
    case 42: ;break;
    case 43: ;break;
    case 44: ;break;
    case 45: ;break;
    case 46: ;break;
    case 47: ;break;
    case 48: ;break;
    case 49: ;break;
    case 50: ;break;
    case 51: ;break;
    case 52: ;break;
    case 53: ;break;
    case 54: ;break;
    case 55: ;break;
    case 56: ;break;
    case 57: ;break;
    case 58: ;break;  //Parität: Datum
    case 59: dcf_sync();break;  //keine Absenkung --> neue Minute
    default: dcf_sync();break;
  }
}

void dcf_1(void)
{
  switch(bit_number)
  {
    case 0: dcf_sync();break;  //Start einer neuen Minute, muß immer 0 sein
    case 1: ;break;  //Wetterdaten
    case 2: ;break;  //Wetterdaten
    case 3: ;break;  //Wetterdaten
    case 4: ;break;  //Wetterdaten
    case 5: ;break;  //Wetterdaten
    case 6: ;break;  //Wetterdaten
    case 7: ;break;  //Wetterdaten
    case 8: ;break;  //Wetterdaten
    case 9: ;break;  //Wetterdaten
    case 10: ;break;  //Wetterdaten
    case 11: ;break;  //Wetterdaten
    case 12: ;break;  //Wetterdaten
    case 13: ;break;  //Wetterdaten
    case 14: ;break;  //Wetterdaten
    case 15: ;break;  //Rufbit für PTB
    case 16: ;break; //Am Ende dieser Stunde wird auf MEZ/MESZ umgestellt
    case 17: dcf_timezone+=1;break;  //Zeitzone: 
    case 18: ;break;  //Zeitzone: dcf_timezone=dcf_timezone
    case 19: ;break;  //Am Ende diese Stunde wird eine Schaltsekunde eingefügt.
    case 20: ;break;  //Beginn der Zeitinformation (immer 1)
    case 21: dcf_minute+=1;dcf_minute_parity+=1;break;
    case 22: dcf_minute+=2;dcf_minute_parity+=1;break;
    case 23: dcf_minute+=4;dcf_minute_parity+=1;break;
    case 24: dcf_minute+=8;dcf_minute_parity+=1;break;
    case 25: dcf_minute+=10;dcf_minute_parity+=1;break;
    case 26: dcf_minute+=20;dcf_minute_parity+=1;break;
    case 27: dcf_minute+=40;dcf_minute_parity+=1;break;
    case 28: dcf_minute_parity+=1;break;  //Parität: Minute
    case 29: dcf_hour+=1;dcf_hour_parity+=1;break;
    case 30: dcf_hour+=2;dcf_hour_parity+=1;break;
    case 31: dcf_hour+=4;dcf_hour_parity+=1;break;
    case 32: dcf_hour+=8;dcf_hour_parity+=1;break;
    case 33: dcf_hour+=10;dcf_hour_parity+=1;break;
    case 34: dcf_hour+=20;dcf_hour_parity+=1;break;
    case 35: dcf_hour_parity+=1;break;  //Parität: Stunde
    case 36: dcf_day+=1;dcf_date_parity+=1;break;
    case 37: dcf_day+=2;dcf_date_parity+=1;break;
    case 38: dcf_day+=4;dcf_date_parity+=1;break;
    case 39: dcf_day+=8;dcf_date_parity+=1;break;
    case 40: dcf_day+=10;dcf_date_parity+=1;break;
    case 41: dcf_day+=20;dcf_date_parity+=1;break;
    case 42: dcf_week_day+=1;dcf_date_parity+=1;break;
    case 43: dcf_week_day+=2;dcf_date_parity+=1;break;
    case 44: dcf_week_day+=4;dcf_date_parity+=1;break;
    case 45: dcf_month+=1;dcf_date_parity+=1;break;
    case 46: dcf_month+=2;dcf_date_parity+=1;break;
    case 47: dcf_month+=4;dcf_date_parity+=1;break;
    case 48: dcf_month+=8;dcf_date_parity+=1;break;
    case 49: dcf_month+=10;dcf_date_parity+=1;break;
    case 50: dcf_year+=1;dcf_date_parity+=1;break;
    case 51: dcf_year+=2;dcf_date_parity+=1;break;
    case 52: dcf_year+=4;dcf_date_parity+=1;break;
    case 53: dcf_year+=8;dcf_date_parity+=1;break;
    case 54: dcf_year+=10;dcf_date_parity+=1;break;
    case 55: dcf_year+=20;dcf_date_parity+=1;break;
    case 56: dcf_year+=40;dcf_date_parity+=1;break;
    case 57: dcf_year+=80;dcf_date_parity+=1;break;
    case 58: dcf_date_parity+=1;break;  //Parität: Datum
    case 59: dcf_sync();break;  //keine Absenkung --> neue Minute
    default: dcf_sync();break;
  }
}
/////////////////////////
//Berechnung Schaltjahr//
/////////////////////////
void leap_year(void)
{
  if(year%4==0 && year%100!=0)
  {
    leapyear=1;  //Schaltjahr, da durch 4 teilbar aber nicht durch 100
  }
  else
  {
    if(year%4!=0)
    {
      leapyear=0;//Kein Schaltjahr, da nicht durch 4 teilbar
    }
    else
    {
      if(year%400==0)
      {
        leapyear=1;//Schaltjahre, da durch 400 teilbar
      }
      else
      {
        leapyear=0;//Kein Schaltjahr, da durch 100 teilbar aber nicht durch 400
      }
    }
  }
}


/////////////////////////////////
//Interrupt Service Routine/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Der Compare Interrupt Handler wird aufgerufen, wenn TCNT0 = OCR0 = 156-1 ist (250 Schritte), d.h. genau alle 10 ms
ISR (TIMER0_COMP_vect)
{
  hundertstelsecond++;  //Counter für die Millisekunden
  dataPC = PINC;  //Der aktuelle Pegel vom DCF-Modul wird eingelesen und in dataPC den anderen Funktionen zur Verfügung gestellt
  counter_high++;  //Counter für die Bit-Auswertung (Dauer des High-Pegels), Rücksetzen muß in den Funktionen geschehen
  counter_low++;  //Counter für die Bit-Auswertung (Dauer des Low-Pegels), Rücksetzen muß in den Funktionen geschehen
  if(hundertstelsecond==100)  //"selbstlaufende" Uhr
  {
    second++;
    hundertstelsecond=0;
    if(second==60)
    {
      minute++;
      second=0;

    }
    if(minute==60)
    {
      hour++;
      minute=0;
    }
    if(hour==24)
    {
      day++;
      week_day++;
      hour=0;
    }
    if(week_day==8)
    {
      week_day=1;
    }
    switch(day)
    {
      case 29:  //Tag 28
      {
        leap_year();
        if(month==2 && leapyear==0)
        {
          month++;
          day=1;
        }
      }
      break;

      case 30:  //Tag 29
      {
        leap_year();
        if(month==2 && leapyear==1)
        {
          month++;
          day=1;
        }
      }
      break;

      case 31:  //Tag 30
      {
        if(month==4 || month==6 || month==9 || month==11)
        {
          month++;
          day=1;
        }
      }
      break;

      case 32:  //Tag 31
      {
        if(month==1 || month==3 || month==5 || month==7|| month==8 || month==10 || month==12)
        {
          month++;
          day=1;
        }
      }
      break;

      default: ;break;
    }
    if(month==13)
    {
      year++;
      month=1;
    }
  }
}

////////////////////////////////////////////////////////
//Zusammenführung der internen Daten und der DCF-Daten//
////////////////////////////////////////////////////////

void match_date(void)
{
  week_day=dcf_week_day;
  day=dcf_day;
  month=dcf_month;
  year=2000+dcf_year;
}

void match_time(void)
{
  hundertstelsecond=0;
  second=0;
  minute=dcf_minute;
  hour=dcf_hour;
  timezone=dcf_timezone;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////Weckzeit///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void weckzeit(void)
{
  if(alarm_stunde==hour)
  {
    if(alarm_minute==minute)
  {   
    if(PORTB >= 0x80)  //wenn LED 8 ein dann
      PORTB = 0x01;  //setzte wieder LED 1
    else
      PORTB = PORTB << 1;  //ansonsten zähle hoch

//    zeit(500);     //0,5s warten    
    }
    else
    {
    PORTB=0x02;
    }
  }
  else
    {
    PORTB=0x02;
    } 
}

///////////////////////
//DCF-Pegelauswertung//
///////////////////////
void level_analysis(void)
{
  if(dataPC & (1<<PINC1))
  {

    if(counter_low>=3 && counter_low<=15)  //logisch 0
    {
//      minute_frame[bit_number]=0;      

      dcf_0();
  
      bit_number++;
      dcf_second++;

      counter_high=0;
      counter_low=0;
    }
    else
    {
      if(counter_low>=16 && counter_low<=30)  //logisch 1
      {
//        minute_frame[bit_number]=1;      
        
        dcf_1();

        bit_number++;

        counter_high=0;
        counter_low=0;
      }
      else
      {
        counter_low=0;
      }
    }
  }
  else
  {
    if(counter_high>=175 && counter_high<=195)
    {
      if(bit_number==59 && dcf_minute_parity%2==0 && dcf_hour_parity%2==0 && dcf_date_parity%2==0)
      {
        bit_number=0;

        match_date();
        match_time();
      }
      else
      {
        dcf_date_reset();
        dcf_time_reset();

        counter_high=0;

        if(year==0)
        {
        dcf_sync();
          }
      }

      counter_high=0;

      dcf_date_reset();
      dcf_time_reset();
    }
  }
}



////////
//Main//
////////
int main(void)
{
  //Setzen der Port-Richtungsregister
  DDRC &= ~(1<<PC1);  //PC1 Eingang (0)
  DDRB = 0xff;
  //Initialisieren der Ports
  PORTC |= (1<<PC1);  //PC1 Pull-Up gesetzt (1)

  lcd_init();  //Initialisierung des LCDs

  // Timer 0 konfigurieren
  TCCR0 = (1<<WGM01) | (1<<CS00) | (1<<CS02);  //CTC Modus (1), Prescaler 1024 (1) (1)
  OCR0 = 156-1; //((16000000/1024)/100) = 156,25
  TIMSK |= (1<<OCIE0);  //Compare Interrupt erlauben (1)
  sei();  //Global Interrupts aktivieren

  dcf_sync();  //Synchronisierung des DCF-Moduls

  while(1)
  {
  level_analysis();
  show_matched_date(0,3);
  show_matched_time(6,2);
//  show_weckzeit(0,4);
//  show_temperatur(17,4);
    weckzeit();
  

  
  }
}

Bin schon sehr gespannt auf eure Ratschläge.

Grüße Oli

[Lurchi (Gast)]

Das Programm macht die Erkennung des Eingangssignal in der While() 
Schleife im Hauptprogramm. Wenn da zu große Verzögerungen eingebaut 
sind, gibt es halt Probleme.

Ich würde einen komplett anderen Programmaufbau wählen, so dass die DCF 
Decodierung komplett im Interrupt läuft: Etwa mit einem Interrupt zum 
Anfang jeder Sekunde und einem etwa 150 ms später. Das Signal vom 
Empfänger dann vorzugsweise auf den ICP Eingang.

[Karl H. (kbuchegg)]

Oliver Go schrieb:

> ich habe das Dekodierprogramm von Johannes M. etwas modifiziert und habe
> mich gewundert, warum ich nicht parallel mehere Operationen gleichzeitig
> ausführen kann, ohne das der DCF-Empfang beeinflusst wird.

Das kommt daher, weil der ganze Programmaufbau mies ist.

[Karl H. (kbuchegg)]

Abgesehen vom Einbau des DCF Teiles.
So was

void dcf_sync(void)
{
...
  if(!(dataPC & (1<<PINC1)))
  {
    if(counter_high>=175 && counter_high<=195)
...
    else
    {
      dcf_sync();
    }
  }
  else
  {
    dcf_sync();
  }
}

geht schon mal gar nicht.
So eine Rekursion kannst du am PC machen, auf dem du Megabyteweise 
Speicher hast. Aber auf einem kleinen µC mit seinem eher bescheidenem 
SRAM kannst du das nicht machen, ohne dass dir mehr oder weniger sofort 
der Speicher ausgeht.
Es ist auch nicht notwendig, dass du hier Rekursionen einsetzt. Die 
Funktionalität lässt sich mit while Schleifen wunderbar und viel simpler 
implementieren.

Edit:
Mal abgesehen davon, dass man das ganz sicher nicht so macht, dass der 
µC aktiv auf den Puls wartet. Hat dein DCF-Modul keinen (oder 
schlechten) Empfang (warum auch immer), dann steht die komplette Uhr.

Fazit: Ich hoffe Johannes hat in der Zwischenzeit gelernt. Muss er 
eigentlich, das Projekt ist ja dann doch schon recht alt). Aber so gehts 
nicht. Dieser Code ist ziemlich mies. und du solltest lernen, dass du 
dich nicht an Projekte halten sollst, in denen im Eröffnungsposting 
steht, dass der Autor selbst Anfänger ist. Das einzige was man im 
Normalfall von denen lernen kann, das ist wie man es nicht macht. Es 
gibt ein paar Leute, die in der Codesammlung wirklich guten Code 
veröffentlicht haben und an die du dich jederzeit halten kannst. Allen 
voran ist sicherlich Peter Danegger zu nennen. Von dem kannst du 
eigentlich ungeschaut so ziemlich jeden Code hernehmen und studieren und 
dabei eine Menge lernen.

[Cube_S (Gast)]

Ich gebe mal meinen Code zum besten:

#define MIN_GAP 480
#define MAX_GAP 520
#define MIN_SEC 240
#define MAX_SEC 260

static bool dcf_state = false;
static bool dcf_parity = false;
static bool dcf_ok = false;
static uint16_t dcf_high = 0;
static uint16_t dcf_low = 0;
static uint8_t dcf_count = 0;
static uint8_t dcf_buffer[8];
static uint8_t dcf_last[8];
static volatile bool dcf_minute = false;

ISR(TIMER0_COMPA_vect)
{
  bool low = (DATA_PIN & (1<<DATA))==0;
  if (config.flags & (1<<DCF_INVERT_BIT))
    low = !low;
    
  if (low)
  {
    LED1_PORT &= ~(1<<LED1);
    if (dcf_state) // falling edge
    {
      dcf_state = false;
      dcf_low = 0;
    }
    else dcf_low++;
  }
  else
  {
    LED1_PORT |= (1<<LED1);
    if (!dcf_state) // rising edge
    {
      uint16_t duration = dcf_low + dcf_high;
      
      bool bit = dcf_high> config.max_zero; // max signal length for 0 (reichelt=25(0x19), conrad=38(0x26))
      
      if (duration>=MIN_GAP && duration<=MAX_GAP) // Ende der Minute
      {
        dcf_parity ^= bit;
        if (dcf_count==58 && dcf_ok && !dcf_parity)
        {
          if (bit)
            dcf_buffer[dcf_count>>3] |= (1<<(dcf_count&7));
          else
            dcf_buffer[dcf_count>>3] &= ~(1<<(dcf_count&7));

          memcpy(dcf_last, dcf_buffer, 8);
          // dcf_last enthält an dieser Stelle eine komplett empfangene Minute          
          dcf_minute = true;
        }
        dcf_count = 0;
        dcf_parity = false;
        dcf_ok = true;
      }
      else if (duration>=MIN_SEC && duration<=MAX_SEC) // Normale Sekunde
      {
        dcf_parity ^= bit;
        switch(dcf_count)
        {
          case 20:
            dcf_parity = false;
            if (!bit) dcf_ok = false;
            break;
          case 28:
            if (dcf_parity) dcf_ok = false;
            dcf_parity = false;
            break;
          case 35:
            if (dcf_parity) dcf_ok = false;
            dcf_parity = false;
            break;
        }
          
        if (dcf_ok)
        {
          if (dcf_count<64)
          {
            if (bit)
              dcf_buffer[dcf_count>>3] |= (1<<(dcf_count&7));
            else
              dcf_buffer[dcf_count>>3] &= ~(1<<(dcf_count&7));
          }
          dcf_count++;
        }
      }
      else
      {
        dcf_count = 0;
        dcf_parity = false;
      }
            
      dcf_state = true;
      dcf_high = 0;
    }
    else dcf_high++;
  }
}

void main()
{
// Interrupt alle 1/250 sec = 4ms bei 16MHz
  OCR0A = 249; 
  TIFR0 = (1<<OCF0A);
  TIMSK0 = (1<<OCIE0A);
  TCCR0A = (1<<WGM01);
  TCCR0B = (1<<CS02);

  while(true)
  {
    if (dcf_minute)
    {
      dcf_minute = false;
      // dcf_last enthält die daten
    }
  }
}

Die Idee: Eben kein Interrupt durch den Empfänger, das kann bei 
schlechten Bedingungen nämlich ziemlich unkontrolliert häufig auftreten. 
Stattdessen wird der Daten-Pin des Empfängers regelmäßig per 
Timer-Interrupt (alle 4ms) abgetastet und ausgewertet. Den Code habe ich 
aus einem laufenden Programm extrahiert, daher ist er ohne Gewähr und 
ohne Anspruch auf Vollständigkeit, also nur ein Diskussionsbeitrag.

[Lurchi (Gast)]

Der Interrupt code, mit Interrupt alle 4 ms sieht schon viel besser aus. 
Es fehlt dort aber noch die Umwandlung vom Bitmuster in die Zeit.

Das Signal des Empfängers direkt auf einen Interrupt ist tatsächlich 
nicht gut. Besser ist es den Interrupt wirklich Zeitgesteuert 1 oder 2 
mal die Sekunden zu haben. Der Timer wird mit einer Art Software PLL an 
den Anfang der Pulse angebunden und kann damit relativ tolerant gegen 
Störungen sein. So werden nur Pulse am Anfang der Sekunde ausgewertet - 
zusätzliche Störpulse werden ignoriert, wenn sie nicht gerade in der 
interessante Zeitfenster fallen.

Das ganze ist ein Abwägung zwischen Aufwand und Empfindlichkeit gegen 
Störungen. Wenn man es weit treibt, werden auch Daten aus 2 oder 3 
Minuten ausgewertet.

[Cube_S (Gast)]

Jede in einem digitalen System gespeicherte Zeit ist ein Bitmuster. Zur 
Ergänzung kann ich hier noch die Umwandlung in ein DS1307-taugliches 
Bitmuster angeben:

        ds1307_set[2] = ((dcf_set[2]>>5)&7)|((dcf_set[3]&15)<<3); // minute
        ds1307_set[3] = ((dcf_set[3]>>5)&7)|((dcf_set[4]&7)<<3); // hour
        ds1307_set[4] = (dcf_set[5]>>2)&7; // weekday
        ds1307_set[5] = ((dcf_set[4]>>4)&15)|((dcf_set[5]&3)<<4); // day
        ds1307_set[6] = ((dcf_set[5]>>5)&7)|((dcf_set[6]&3)<<3); // month
        ds1307_set[7] = ((dcf_set[6]>>2)&63)|((dcf_set[7]&3)<<6); // year

dcf_set wäre durch dcf_last aus dem letzen Schnipsel zu ersetzen. 
ds1307_set[0..1] fehlen hier, denn die sind nur für TWI (Start-Adresse) 
bzw. Sekunde verantwortlich was in diesem Zusammenhang nicht 
interessiert. Ansonsten sind die Werte BCD codiert.