DCF Problem mit Code

[Jonas E. (jonas_e43)]

Hallo,
Ich bin gerade dabei eine LCD Uhr auf Atmega32 Basis zu programmieren.
Ich habe das Forum bereits durchsucht. Jedoch funktionieren die Codes 
mit meinem Setup nicht bzw. sind zu komplex, als dass ich sie 
umschreiben könnte.

Habt ihr vielleicht etwas Beispielcode oder eine Library, den/die ich 
verwenden könnte? Das DCF Modul ist am INT0 Pin des Atmega angschlossen.

Gruß
Jonas

[ich (Gast)]

http://www.mikrocontroller.net/search?query=DCF+code&forums[]=1&forums[]=19&forums[]=9&forums[]=10&forums[]=2&forums[]=4&forums[]=3&forums[]=6&forums[]=31&forums[]=17&forums[]=11&forums[]=8&forums[]=14&forums[]=12&forums[]=7&forums[]=5&forums[]=15&forums[]=13&forums[]=18&forums[]=16&max_age=-&sort_by_date=0

Zu dem Thema gab's schon so viel hier im Forum, die vielen Einträge will 
ich jetzt nicht durch einen weiteren ergänzen. Es sind massenhaft dabei, 
die funktionieren.

[Jonas E. (jonas_e43)]

So ich habe mal diesen Code für mein Projekt angepasst, um damit die DCF 
Zeit zu empfangen, nur leider wird wenn ich dcf_sync starte die ganze 
Main aufgehalten und der bildschirm flackert... Woran könnte das liegen?

//Header Dateien
#include <avr/interrupt.h>
#include "dcf_clock.h"

/////////////
//Variablen//
/////////////
//date
uint8_t week_day;
uint8_t day;
uint8_t month;
uint16_t year;

//time
uint16_t millisecond;
uint8_t second;
uint8_t minute;
uint8_t hour;
uint8_t timezone;

//Speicherbereich für DCF-Pegel
uint8_t dataPC;

//Pegel-Auswertung
uint16_t counter_high;
uint16_t counter_low;
uint8_t bit_number;

//dcf_date
uint8_t dcf_week_day;
uint8_t dcf_day;
uint8_t dcf_month;
uint8_t dcf_year;
uint8_t dcf_date_parity;

//dcf_time
uint8_t dcf_second;
uint8_t dcf_minute;
uint8_t dcf_minute_parity;
uint8_t dcf_hour;
uint8_t dcf_hour_parity;
uint8_t 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
uint8_t leapyear;

void initClock(void)
{
  //Setzen der Port-Richtungsregister
  DDRD &= ~(1<<PD2);  //PD2 Eingang (0)
  //Initialisieren der Ports
  //PORTD |= (1<<PD2);  //PD2 Pull-Up gesetzt (1)

  // Timer 1 konfigurieren
  TCCR1A = 0;
  TCCR1B |=(1<<WGM12)|(1<<CS12);
  OCR1A = 57;
  TIMSK |= (1<<OCIE1A);  //Compare Interrupt erlauben (1)
}


////////////////////
//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;
}

///////////////////////
//DCF-Synchronisation//
///////////////////////
//High-Pegel muß für 1700-1900ms anliegen
//Danach muß ein Low-Pegel folgen
void dcf_sync(void)
{
  if(!(dataPC & (1<<PIND2)))
  {
    if(counter_high>=1750 && counter_high<=1950)
    {
      
      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 = 250-1 ist (250 Schritte), d.h. genau alle 1 ms
ISR (TIMER1_COMPA_vect)
{
  millisecond++;  //Counter für die Millisekunden
  dataPC = PIND;  //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(millisecond==1000)  //"selbstlaufende" Uhr
  {
    second++;
    millisecond=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)
{
  millisecond=0;
  second=0;
  minute=dcf_minute;
  hour=dcf_hour;
  timezone=dcf_timezone;
}

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

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

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

      counter_high=0;
      counter_low=0;
    }
    else
    {
      if(counter_low>=160 && counter_low<=240)  //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>=1750 && counter_high<=1950)
    {
      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;

        dcf_sync();
      }

      counter_high=0;

      dcf_date_reset();
      dcf_time_reset();
    }
  }
}

Gruß Jonas

[Karl H. (kbuchegg)]

Wenn ein LCD flackert, dann liegt das praktisch immer an exzessiven 
Aufrufen der LCD-Lösch Funktion.
Ich kann leider deine Ausgabefunktion nicht sehen, bzw. wie und wo sie 
eingesetzt wird. D.h. man kann auch nicht verfolgen, wie oft während des 
Empfangs eines Telegrams ein Display-Update angestossen wird.

[holger (Gast)]

void dcf_sync(void)
{
 ...
     dcf_sync();
...
    dcf_sync();
...
 }

Rekursiver Selbstaufruf. Naja.

[Karl H. (kbuchegg)]

holger schrieb:

> Rekursiver Selbstaufruf. Naja.

Autsch: Wer macht denn aber auch sowas.
Ich hab nur nach Schleifen abgesucht.

[holger (Gast)]

>> Rekursiver Selbstaufruf. Naja.
>
>Autsch: Wer macht denn aber auch sowas.
>Ich hab nur nach Schleifen abgesucht.

Die ist doch da;)

Rekursiver Selbstmord-> Reset -> Rekursiver Selbstmord-> Reset.
Display flackert weil es ständig neu initialisiert wird;)

[Jonas E. (jonas_e43)]

Ich hatte die Quelldatei von einer DCF Uhr benutzt. (Siehe Anhang und 
sie etwas abgeändert. Aber dieser Aufruf soll ausgeführt werden...
siehe (Beitrag "DCF-Uhr mit LCD in C").
Habe den rekursiven Aufruf jetzt rausgenommen.
Aber leider wird immer noch nicht die korrekte Zeit empfangen

[R. F. (rfr)]

Was ist mit assert?
was ist mit fprintf?
Warum programmierst du nicht so, dass og.  dir erklären, was dein 
Programm macht und du erkennen kannst, wann das davon abweicht, was es 
machen soll?`

Und poste den Quelltext doch bitte als Anhang.

Grüsse

Robert

[Karl H. (kbuchegg)]

holger schrieb:

>>Autsch: Wer macht denn aber auch sowas.
>>Ich hab nur nach Schleifen abgesucht.
>
> Die ist doch da;)
>
> Rekursiver Selbstmord-> Reset -> Rekursiver Selbstmord-> Reset.

Das ist schon klar.
Ich habs nur nicht gesehen, weil ich gar nicht auf die Idee gekommen 
bin, da nach Rekursionen Ausschau zu halten.

[Karl H. (kbuchegg)]

Jonas E. schrieb:

> Aber leider wird immer noch nicht die korrekte Zeit empfangen

Tja. Dann musst du eben Debuggen.

Ich würde mal damit anfangen, die ermittelten Zeiten mir wo ausgeben zu 
lassen und das dann mal studieren. Und zwar unabhängig von irgendeiner 
bereits implementierten Uhren-Software.

[Jonas E. (jonas_e43)]

Hier einmal der Programm Code, in welchem das DCF-Modul verwendet wird.
Vielleicht hilft das ein bisschen mehr.
Was meinst du mit assert und fprintf?
Ich bin noch ein Neuling in C und hoffe das ihr mir bei meine 
programmier Fautpas etwas helfen könnt.
Gruß Jonas

[Karl H. (kbuchegg)]

Hmm. Der COde ist überhaupt etwas seltsam.
Such dir einen DCF-Code von Peter Danegger. Da gibts sicher was in der 
Codesammlung. Der funktioniert dann wenigstens auch.

[R. F. (rfr)]

Jonas E. schrieb:
> Hier einmal der Programm Code, in welchem das DCF-Modul verwendet wird.
> Vielleicht hilft das ein bisschen mehr.

DU musst dir helfen. WIR geben Tips, aber eigentlich schreibt hier 
keiner Auftragssoftware.


> Was meinst du mit assert und fprintf?

Die Funktionen dieses Namens, nachzulesen in deriner Doku oder durch 
Googeln.

> Ich bin noch ein Neuling in C und hoffe das ihr mir bei meine
> programmier Fautpas etwas helfen könnt.

Das ist nicht vollkommen unbemerkt geblieben.
> Gruß Jonas


dto.
Robert

[Jonas E. (jonas_e43)]

Natürlich versuche ich mir selbst zu helfen und ich würde auch nicht 
nachfragen, wenn ich selbst darauf gekommen wäre. Dies ist leider ja 
nicht der Fall.

[Jonas E. (jonas_e43)]

Auf Karl Heinz Hinweis habe ich weiter nach einem möglichen DCF Code 
gesucht und auch einen gefunden. Dieser überprüft den INT0 Eingang und 
löst dann ein Interrupt aus. Nur leider empfängt der uC trotzdem nicht 
die Zeit...
Könnte das an den Interrupt Einstellungen liegen?

dcf_clock.c

/*#######################################################################################
AVR DCF77 Clock

Copyright (C) 2005 Ulrich Radig

#######################################################################################*/

#include "dcf_clock.h"

#include <avr/io.h>
#include <avr/interrupt.h>


//Die Uhrzeit seht in folgenden Variablen
volatile unsigned char ss   = 0;   //Globale Variable für die Sekunden
volatile unsigned char mm   = 0;   //Globale Variable für die Minuten
volatile unsigned char hh   = 0;   //Globale Variable für die Stunden
volatile unsigned char day   = 0;   //Globale Variable für den Tag
volatile unsigned char mon   = 0;   //Globale Variable für den Monat
volatile unsigned int year   = 0;   //Globale Variable für das Jahr
volatile bool shouldRender = false;

//Bitzähler für RX Bit
volatile unsigned char rx_bit_counter = 0;

//64 Bit für DCF77 benötigt werden 59 Bits
volatile unsigned long long dcf_rx_buffer = 0;

//Hilfs Sekunden Counter
volatile unsigned int h_ss = 0;

//Hilfs Variable für Stundenwechsel
volatile unsigned int h_hh = 0;

//############################################################################
//Overflow Interrupt wird ausgelöst bei 59Sekunde oder fehlenden DCF77 Signal
SIGNAL(TIMER1_OVF_vect)
//############################################################################
{
  struct  DCF77_Bits *rx_buffer;
  rx_buffer = (struct DCF77_Bits*)(char*)&dcf_rx_buffer;
  
  //Zurücksetzen des Timers
  TCNT1 = 65535 - (SYSCLK / 1024);
  //wurden alle 59 Bits empfangen und sind die Paritys richtig?
  if (rx_bit_counter == 59 &&
  flags.parity_P1 == rx_buffer->P1 &&
  flags.parity_P2 == rx_buffer->P2 &&
  flags.parity_P3 == rx_buffer->P3)
  //Alle 59Bits empfangen stellen der Uhr nach DCF77 Buffer
  {
    //Berechnung der Minuten BCD to HEX
    mm = rx_buffer->Min-((rx_buffer->Min/16)*6);
    
    if (mm != 0){mm--;}else{mm = 59; h_hh = 1;};
    
    //Berechnung der Stunden BCD to HEX
    hh = rx_buffer->Hour-((rx_buffer->Hour/16)*6);

    if (h_hh) {hh--;h_hh = 0;};

    //Berechnung des Tages BCD to HEX
    day= rx_buffer->Day-((rx_buffer->Day/16)*6);
    //Berechnung des Monats BCD to HEX
    mon= rx_buffer->Month-((rx_buffer->Month/16)*6);
    //Berechnung des Jahres BCD to HEX
    year= 2000 + rx_buffer->Year-((rx_buffer->Year/16)*6);
    //Sekunden werden auf 0 zurückgesetzt
    ss = 59;
    flags.dcf_sync = 1;
  }
  else
  //nicht alle 59Bits empfangen bzw kein DCF77 Signal Uhr läuft
  //manuell weiter
  {
    shouldRender = true;
    Add_one_Second();
    flags.dcf_sync = 0;
  }
  //zurücksetzen des RX Bit Counters
  rx_bit_counter = 0;
  //Löschen des Rx Buffers
  dcf_rx_buffer = 0;
};

//############################################################################
//DCF77 Modul empfängt Träger
SIGNAL (DCF77_INT)
//############################################################################
{
  //Auswertung der Pulseweite
  if (INT0_CONTROL == INT0_RISING_EDGE) //normal rising
  {
    flags.dcf_rx ^= 1;
    //Secunden Hilfs Counter berechnen // SYSCLK defined in USART.H
    h_ss = h_ss + TCNT1 - (65535 - (SYSCLK / 1024));
    //Zurücksetzen des Timers
    TCNT1 = 65535 - (SYSCLK / 1024);
    //ist eine Secunde verstrichen // SYSCLK defined in USART.H
    if (h_ss > (SYSCLK / 1024 / 100 * 90)) //90% von 1Sekunde
    {
      //Addiere +1 zu Sekunden
      Add_one_Second();
      //Zurücksetzen des Hilfs Counters
      h_ss = 0;
    };
    //Nächster Interrupt wird ausgelöst bei abfallender Flanke
    INT0_CONTROL = INT0_FALLING_EDGE;
  }
  else
  {
    //Auslesen der Pulsweite von ansteigender Flanke zu abfallender Flanke
    unsigned int pulse_wide = TCNT1;
    //Zurücksetzen des Timers
    TCNT1 = 65535 - (SYSCLK / 1024);
    //Secunden Hilfs Counter berechnen
    h_ss = h_ss + pulse_wide - (65535 - (SYSCLK / 1024));
    //Parity speichern
    //beginn von Bereich P1/P2/P3
    if (rx_bit_counter ==  21 || rx_bit_counter ==  29 || rx_bit_counter ==  36)
    {
      flags.parity_err = 0;
    };
    //Speichern von P1
    if (rx_bit_counter ==  28) {flags.parity_P1 = flags.parity_err;};
    //Speichern von P2
    if (rx_bit_counter ==  35) {flags.parity_P2 = flags.parity_err;};
    //Speichern von P3
    if (rx_bit_counter ==  58) {flags.parity_P3 = flags.parity_err;};
    //Überprüfen ob eine 0 oder eine 1 empfangen wurde
    //0 = 100ms
    //1 = 200ms
    //Abfrage größer als 150ms (15% von 1Sekund also 150ms)
    if (pulse_wide > (65535 - (SYSCLK / 1024)/100*85))
    {
      //Schreiben einer 1 im dcf_rx_buffer an der Bitstelle rx_bit_counter
      dcf_rx_buffer = dcf_rx_buffer | ((unsigned long long) 1 << rx_bit_counter);
      //Toggel Hilfs Parity
      flags.parity_err = flags.parity_err ^ 1;
    }
    //Nächster Interrupt wird ausgelöst bei ansteigender Flanke
    INT0_CONTROL = INT0_RISING_EDGE;
    //RX Bit Counter wird um 1 incrementiert
    rx_bit_counter++;
  }
};

//############################################################################
//Addiert 1 Sekunde
void Add_one_Second (void)
//############################################################################
{
  ss++;//Addiere +1 zu Sekunden
  if (ss == 60)
  {
    ss = 0;
    mm++;//Addiere +1 zu Minuten
    if (mm == 60)
    {
      mm = 0;
      hh++;//Addiere +1 zu Stunden
      if (hh == 24)
      {
        hh = 0;
      }
    }
  }
};

//############################################################################
//Diese Routine startet und inizialisiert den Timer
void Start_Clock (void)
//############################################################################
{
  //Interrupt DCF77 einschalten auf ansteigende Flanke
  DCF77_INT_ENABLE();
  INT0_CONTROL = INT0_RISING_EDGE; //Normal Rising Edge
  
  //Interrupt Overfolw enable
  TIMSK1 |= (1 << TOIE1);
  //Setzen des Prescaler auf 1024
  TCCR1B |= (1<<CS10 | 0<<CS11 | 1<<CS12);
  TCNT1 = 65535 - (SYSCLK / 1024);
  shouldRender = false;
  return;
};

dcf_clock.h

/*#######################################################################################
AVR DCF77 Clock

Copyright (C) 2005 Ulrich Radig

#######################################################################################*/

#ifndef _CLOCK_H
#define _CLOCK_H

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdbool.h>

/*typedef struct {
  
} time_t;*/
volatile unsigned char ss;  //Globale Variable für Sekunden
volatile unsigned char mm;  //Globale Variable für Minuten
volatile unsigned char hh;  //Globale Variable für Stunden
volatile unsigned char day;  //Globale Variable für den Tag
volatile unsigned char mon;  //Globale Variable für den Monat
volatile unsigned int year;  //Globale Variable für den Jahr
volatile bool shouldRender;
extern void Start_Clock (void); //Startet die DCF77 Uhr
extern void Add_one_Second (void);

#ifndef SYSCLK
    #define SYSCLK 14745600UL
#endif //SYSCLK  

//64 Bit für DCF77 benötigt werden 59 Bits
volatile unsigned long long dcf_rx_buffer;
//RX Pointer (Counter)
volatile extern unsigned char rx_bit_counter;
//Hilfs Sekunden Counter
volatile unsigned int h_ss;

#if defined (__AVR_ATmega32__)
//Interrupt an dem das DCF77 Modul hängt hier INT0
#define DCF77_INT_ENABLE()  GICR |= (1<<INT0);
#define DCF77_INT      INT0_vect
#define INT0_CONTROL    MCUCR
#define INT0_FALLING_EDGE  0x02
#define INT0_RISING_EDGE  0x03
#define TIMSK1         TIMSK
#endif
//Structur des dcf_rx_buffer
struct  DCF77_Bits {
  unsigned char M          :1  ;
  unsigned char O1      :1  ;
  unsigned char O2      :1  ;
  unsigned char O3      :1  ;
  unsigned char O4      :1  ;
  unsigned char O5      :1  ;
  unsigned char O6      :1  ;
  unsigned char O7      :1  ;
  unsigned char O8      :1  ;
  unsigned char O9      :1  ;
  unsigned char O10      :1  ;
  unsigned char O11      :1  ;
  unsigned char O12      :1  ;
  unsigned char O13      :1  ;
  unsigned char O14      :1  ;
  unsigned char R          :1  ;
  unsigned char A1      :1  ;
  unsigned char Z1      :1  ;
  unsigned char Z2      :1  ;
  unsigned char A2      :1  ;
  unsigned char S          :1  ;
  unsigned char Min      :7  ;//7 Bits für die Minuten
  unsigned char P1      :1  ;//Parity Minuten
  unsigned char Hour      :6  ;//6 Bits für die Stunden
  unsigned char P2      :1  ;//Parity Stunden
  unsigned char Day      :6  ;//6 Bits für den Tag
  unsigned char Weekday    :3  ;//3 Bits für den Wochentag
  unsigned char Month        :5  ;//3 Bits für den Monat
  unsigned char Year        :8  ;//8 Bits für das Jahr **eine 5 für das Jahr 2005**
  unsigned char P3      :1  ;//Parity von P2
};

struct
{
  volatile char parity_err          :1  ;//Hilfs Parity
  volatile char parity_P1          :1  ;//Berechnetes Parity P1
  volatile char parity_P2          :1  ;//Berechnetes Parity P2
  volatile char parity_P3          :1  ;//Berechnetes Parity P3
  volatile char dcf_rx          :1  ;//Es wurde ein Impuls empfangen
  volatile char dcf_sync          :1  ;//In der letzten Minuten wurde die Uhr syncronisiert
}flags;

#endif //_CLOCK_H

[Karl H. (kbuchegg)]

Jonas E. schrieb:
> Auf Karl Heinz Hinweis habe ich weiter nach einem möglichen DCF Code
> gesucht und auch einen gefunden. Dieser überprüft den INT0 Eingang und
> löst dann ein Interrupt aus. Nur leider empfängt der uC trotzdem nicht
> die Zeit...
> Könnte das an den Interrupt Einstellungen liegen?

Probiers halt aus.
Schmeiss aus dem Programm alles ausser dem

//############################################################################
//DCF77 Modul empfängt Träger
SIGNAL (DCF77_INT)
//############################################################################
{
}

und den Interrupt Einstellungen raus, lass im Interrupt eine LED toggeln 
und dann siehst du nach ob die im richtigen Takt blinkt.

Die Technik, ich such mir da einen Code und alles ist in Butter, 
funktioniert manchmal. Manchmal funktioniert sie aber NICHT. Und dann 
bist du mit deinen Debug-Fähigkeiten gefragt. Und die beginnen nun mal 
damit, dass man von vorne bis hinten alles überprüft. Der Code ist 
darauf angewiesen einen regelmässigen Aufruf der ISR, abgeleitet vom 
Signal des DCF Empfängers zu kriegen. Also wird das mal geprüft. Dazu 
brauch ich keine DCF Auswertung, dazu brauch ich keine Uhr.
Einfach den DCF-Empfänger an den Mega ankabeln und nachsehen ob die 
Interrupts kommen oder nicht. Kommen sie, dann ist der Teil mal abgehakt 
und ich nehm mir den nächsten Schritt vor. Kommen sie nicht, dann muss 
man dem nachgehen warum sie nicht kommen.

Und so geht das sukzessive voran.
So ist das nun mal. µC-Hardware sind unterschiedliche. DCF-Empfänger 
sind unterschiedlich. Das ist nicht so wie am PC, wo welteweit 847 
Millionen PC sich unter Windows mehr oder weniger gleich verhalten und 
man daher ein Programm von einem Japaner auf seinen PC laden kann und 
das läuft aus dem Stand heraus.

[Jonas E. (jonas_e43)]

Okay.
Ich habe die ISR jetzt so angepasst.

//############################################################################
//DCF77 Modul empfängt Träger
SIGNAL (DCF77_INT)
//############################################################################
{
  if (PIND & (1<<PD6))
  PORTD &= ~(1<<PD6);
  else
  PORTD |= ( 1 << PD6 );
};

Die LED geht leider nur am Anfang an und nicht wieder aus.
Ich benutze diese Interrupt Einstellungen:

#define DCF77_INT_ENABLE()  GICR |= (1<<INT0);
#define DCF77_INT      INT0_vect
#define INT0_CONTROL    MCUCR
#define INT0_FALLING_EDGE  0x02
#define INT0_RISING_EDGE  0x03
#define TIMSK1         TIMSK

DCF77_INT_ENABLE();
INT0_CONTROL = INT0_RISING_EDGE; //Normal Rising Edge

Woher könnte das wohl kommen?

[Karl H. (kbuchegg)]

Jonas E. schrieb:

> Woher könnte das wohl kommen?

Das könnte zb davon kommen, dass dein DCF Modul zu schwach auf der Brust 
ist, um den Pin auf High oder Low zu ziehen. Einigen Pollin Modulen sagt 
man zb nach, dass sie ohne Signalaufbereitung da probleme haben.


Es könnte aber auch sein, dass dein DCF Modul einen Open-Collector 
Ausgang hat und daher ein Pullup-Widerstand an die Signalleitung muss.

[Jonas E. (jonas_e43)]

Ich benutze das DCF Modul von ELV 
(http://www.elv.de/dcf-empfangsmodul-dcf-2.html). Habe schon zwischen 
Data und VCC einen 10k Pull Up Widerstand geschaltet.

[Karl H. (kbuchegg)]

Dann eben noch einen Schritt einfacher:

Programm welches den Pegel des Input Pins, an dem das Modul hängt auf 
eine LED ausgibt. Blinkt die LED - ja oder nein?

Alternativ könnte man da auch eine Transistorstufe direkt an den Ausgang 
hängen und damit mal nachsehen, ob da aus dem Modul überhaupt was 
rauskommt. Aber wenn ich einen µC habe, der mit dem richtigen Programm 
mir dieselbe Information liefern kann, dann ziehe ich das normalerweise 
vor.

[Mr. Tom (Gast)]

Jonas E. schrieb:
> Könnte das an den Interrupt Einstellungen liegen?

Könntest du deine seitenlangen Quelltext vielleich mal als Anhang 
anfügen? So ist es arg schwierig, die Beiträge dazwischen rauszufiltern.

[Jonas E. (jonas_e43)]

Muss ich den Pin PD2 auf Input schalten, damit ein Interrupt ausgelöst 
werden kann?

[Karl H. (kbuchegg)]

Jonas E. schrieb:
> Muss ich den Pin PD2 auf Input schalten, damit ein Interrupt ausgelöst
> werden kann?

Das wäre der Situation ... sagen wir mal ... zuträglich.

[Jonas E. (jonas_e43)]

So ich bin jetzt mal ganz vom Anfang gestartet.
Ich hab eine LED zwischen dem Daten Pin des DCF Moduls und dem GND PIN 
des Moduls gehalten. Die Led blinkt jede Sekunde. Das müsste doch 
bedeuten, dass das Modul noch funktioniert oder?

[Karl H. (kbuchegg)]

Jonas E. schrieb:
> So ich bin jetzt mal ganz vom Anfang gestartet.
> Ich hab eine LED zwischen dem Daten Pin des DCF Moduls und dem GND PIN
> des Moduls gehalten. Die Led blinkt jede Sekunde. Das müsste doch
> bedeuten, dass das Modul noch funktioniert oder?

So kann man das interpretieren.

Ergo - nächster Schritt:
Daten-Leitung an den µC Pin und einfach nur mal einlesen und eine LED 
entsprechend schalten.

Danach dann dasselbe mit einem externen Interrupt.

[Jonas E. (jonas_e43)]

Funktioniert auch.
Die Led am Atmega32 blikt in der ISR Routine in einem bestimmten 
Rhythmus.

[Karl H. (kbuchegg)]

Jonas E. schrieb:
> Funktioniert auch.
> Die Led am Atmega32 blikt in der ISR Routine in einem bestimmten
> Rhythmus.

Schön.
Dann füll die ISR mit Leben - sprich mit Code, den du dir bei deinen 
"Vorlagen" ausleihst.

[Jonas E. (jonas_e43)]

Hab ich gemacht,
nur leider wird die Uhrzeit nicht auf die aktuellen Daten geändert...
Könnte das am invertieren Signal liegen?