DCF77 Signale auswerten

[Yen L. (yenlo)]

Moin, ich stehe gerade auf dem Schlauch beim Versuch DCF Signale 
auszuwerten.

DCF-Modul: Conrad und es wird der nicht(!)-invertierte Ausgang 
abgenommen und via INT0/PD2 eingelesen. Dafür habe ich die 
"lcd-routines" auf Port C umgebogen.
AVR: AtMega8 bei 1 Mhz internem Takt mit 1ms Ticker
Kontroll LEDs: PB2 - Sekundentakt; PB1 - DCF Signal

Der Sekundentakt PB2 passt und die DCF Kontrolleuchte PB1 toggelt 
passend zum DCF Signal vor sich hin. Die DCFZeitdauer wird in 
Millisekunden gelesen und im LCD als "eins" und "null" interpretiert. 
Soweit so gut -
allerdings erreicht mein DCF-Zähler keine Sync-Dauer und wird deutlich 
vor 1700ms genullt :-/

Jetzt @work und fern des Projekts sitzend fallen mir ein:
- nehme ich das richtige Signal ab oder muss ich die Pinabfrage am PIN 
umdrehen?
- gibt es beim AtMega8 und uint16_t etwas zu beachten?
oder mache ich ganz woanders Mist?


Code (noch nicht aufgeräumt):

#include <avr/io.h>
#include <avr/interrupt.h>
#include "LCD-Routines.h"  // geaendert auf PORT-C
#include <stdlib.h>

#define F_CPU 100000L     // interner Takt 1 MHz
volatile uint16_t internalTime = 0;      // fuer Sekunde
// dcf Zeit
volatile uint16_t dcfTime = 0;      // Signaldauer INT0 DCF
volatile uint16_t dcfAnz =0;
volatile uint8_t dcfFlag =0;


/**********************************************
* Interrupt Routinen
**********************************************/
ISR (TIMER2_COMP_vect) {
  internalTime++;              // 1ms
  if (internalTime == 1000) {  // 1000ms (0-999) = 1 Sek
    internalSek++;           // Sekunden hoch  
    internalTime = 0;
    PORTB ^= (1 << PB2);     // Kontrolle LED PB2
  }
  
  // INT0 abfragen
  if (PIND &(1 << DDD2)) {
    PORTB |= (1 << PB1);     // Kontrolle LED PB1 an
    dcfTime++;
    dcfFlag=1;
  } else   if (!(PIND &(1 << DDD2))) {
    PORTB &= ~(1 << PB1);     // Kontrolle LED PB1 aus
      if (dcfFlag == 1) {  
      dcfAnz=dcfTime;
      dcfTime = 0;
      dcfFlag = 0;
    }    
  }

}


// Ueberwachung INT0 - DCF77-Eingang
ISR (INT0_vect) {
  // foo
}


// ****************************** MAIN *********************
int main(void) {
   internalTime = 0;  // Start interner Zeitzaehler
   dcfAnz = 0;   
   dcfTime = 0;
   dcfFlag =0;     
   
   // PORT B als Ausgänge
   DDRB |= (1 << DDB1) | (1 << DDB2); // PB1 und PB2 als LED OUT
   PORTB &= ~(1 << PB1);      // PB1 aus
   PORTB &= ~(1 << PB2);      // PB2 aus
   
   // PORT D als Eingang fuer INT0
   DDRD &= ~(1 << DDD2);  // INT0 als Eingang
   MCUCR = (1 << ISC00) | (1 << ISC01);   // steigende Flanke INT0
   GICR = (1 << INT0);                    // IRQ an INT0 zulassen
   
   // Timer2 als Millisekundencounter
   TIMSK  |= (1 << TOIE2) | (1 << OCIE2);
   OCR2 = 125 - 1;          // Compare gegen 125 für 1 ms
   TCCR2  |= (1 << CS21);   // Prescaler Timer2 = 8
   TCCR2  |= (1 << WGM21);   // Compare Mode CTC zulassen
   sei();                   // Interrupts global zulassen
   
   // **** LCD ****
   lcd_init();
   
   
    while(1)
    {
      // DCF Signal = AUS
      if (dcfAnz >=60 && dcfAnz <= 140) {
       lcd_setcursor(0,1);
       lcd_string("DCF: NULL ");
      // DCF Signal = EIN
      } else if (dcfAnz >=150 && dcfAnz <=260) {
         lcd_setcursor(0,1);
         lcd_string("DCF: EINS ");
       // DCF Signal = SYNC
      } else if (dcfAnz >=1700 && dcfAnz <=2200) {
         lcd_setcursor(0,1);
         lcd_string("DCF: SYNC ");
      } 
    
    }
}

[Yen L. (yenlo)]

Soweit habe ich das mit dem DCF Signal und der Uhrzeit hinbekommen.
Allerdings sehe ich alle 4 Minuten eine Bitverschiebung, als ob der Sync 
an der Stelle nur als 1 Sek und nicht als 2 Sek Intervall interpretiert 
ist..

schaue ich mir morgen mal in Ruhe an

[Yen L. (yenlo)]

Fehler gefunden. Das Conrad Modul läuft jetzt seit knapp ner Stunde 
stabil mit der DCF Zeit/Datumsanzeige.

Einen Großteil der Lösungen habe ich hier im Forum in diversen 
Problembeschreibungen oder Tutorials finden können. Dafür Danke an alle, 
die sich hier im Forum engagiert haben ;)

[Martin K. (maart)]

Und was war der Fehler?

[Yen L. (yenlo)]

Martin Kreiner schrieb:
> Und was war der Fehler?

Bei der Signalauswertung: In meinen Setup werte ich Inverse aus(könnte 
man auch andersherum machen... ist ja wurscht ;)

Der Fehler lag am ungeschickt ausgelagertem Aufbau der 
Auswertungsroutine, die periodisch zuviel Zeit gefressen hat. Das 
Herzstück sieht nun so aus und lief von gestern abend bis heute früh 
ohne Ausreisser - Code noch unbereinigt und ressoucenverschwendend:

ISR (TIMER2_COMP_vect) {
  internalTime++;              // 1ms
  if (internalTime == 1000) {  // 1000ms (0-999) = 1 Sek
    internalSek++;           // Sekunden hoch
    internalTime = 0;
    PORTB ^= (1 << PB2);     // Kontrolle LED PB2
    showInternal=1;
    intUhrzeit();
  }

  // INT0 abfragen
  if (!(PIND &(1 << DDD2))) {
    PORTB |= (1 << PB1);     // Kontrolle LED PB1 an
    dcfTime++;
    dcfFlag=1;
  } else   {
  // if ((PIND &(1 << DDD2))) {
    PORTB &= ~(1 << PB1);     // Kontrolle LED PB1 aus
    if (dcfFlag == 1) {
      dcfBit=dcfTime;
      dcfTime = 0;
      dcfFlag = 0;

      // --- Signalauswertung --
      if (dcfBit >=760 && dcfBit <= 832) {  //um 325 hex
        signalDCF[arrayCounter]=0;

      // DCF Signal = EIN
      } else if (dcfBit >=850 && dcfBit <=1000) { //um 385 hex
        signalDCF[arrayCounter]=1;

      // DCF Signal = SYNC
      } else if (dcfBit >=1600 && dcfBit <=2200) { // 702 hex
        normalSync=1;
        arrayCounter=255;
        if (rtcSync == 0) {  // erstmaliger SYNC?
          rtcSync =1;
          internalSek=0;
          internalMin=0;
          internalHour=0;
        }
        dcfZeit();
      }
      arrayCounter++;
    }

  }

}