DCF77 Code, Paritätsprüfung klappt nicht

[Matze (Gast)]

Hallo,

Ich Habe folgenden Code zur DCF77-Decodierung geschrieben,
Grundsätzlich funktioniert alles Notwendige.
Jedoch gibt es 2 Probleme:
Der Paritätsckek des Datums ist immer Falsch
Gibts es da vielleicht ein Schleifen / Array-Überlauf Problem?

Wenn ich bewust Fehler einstreue, z.b. im Minuten-Teil der übertragung,
kommt es bei der Auswertung vor, dass die Minute sich nicht verändert.
Sie ist dann falsch, dennoch ist die Parität, sowie Sinhaftigkeit des 
wertes <9 gegeben.

Es wird also die Zeile 
getZeitinAnzeige(&Anzeige[3],3,25);
            Anzeige[1].dp=1;    //Anzeige Parität der Minute OK
in der vielfachen if-Abfrage ausgeführt.
Da dies passiert, ist angeblich die Parität richtig und der Wert 
sinvoll.
Gleichzeitig bleibt die Minute jedoch stehen, und läuft nicht weiter.
Folglich ist ein Fehler, den ich absichtlich eingestreut habe 
eingetreten.
Das einstreuen des Fehlers führt jedoch niemals zu Falscher Parität der 
Form:
            Anzeige[1].dp=0;
in den Else-Zweigen einer der IF-Abfragen.
Die Zeit bleibt stehen, und dennoch ist angeblich immer alles richtig.
Da ich das bestimmt schon 10 mal getestet habe, wird es lansgam sehr 
unwahrscheinlich.

Sieht vielleicht jemand das Problem?

#define F_CPU 4000000UL
#include <avr/interrupt.h>
#include "delay.h"
#include "DS1820.h"
#include "Uhr.h"


/*unsigned short int C_Halbe=0;
unsigned short int C_Einer=0;
unsigned short int C_Zehner=0;
unsigned short int VZ=0;*/

short volatile unsigned int DCF77flag;
volatile unsigned short int count1;
volatile unsigned short int count0;
volatile short int Prot_Start;
unsigned short int Temperatur[6];

int main()
{
  Init();
  Anzeige[0].Zahl=0;  //einer  Sek
  Anzeige[1].Zahl=0;  //Zehner Sek
  Anzeige[2].Zahl=0;  //einer  min 
  Anzeige[3].Zahl=0;  //Zehner min
  Anzeige[4].Zahl=0;  //Einer  Std
  Anzeige[5].Zahl=0;  //Zehner Std
  count1=0;
  count0=0;
  Prot_Start=-1;
  while(1)
  {      
    ;
  }
}

void Init()
{
  int A=1;
  //Port-Einstell
  DDRA|=0xff;      //Port A = Ausgabe
  DDRC|=0xfc;      //PORT C = Ausgabe Anode
  DDRB&=0xf0;      //Port B = 3 Taster, DS1820 als Eingabe
  DDRD&=0x00;      //Port D = Eingabe 
  //--------------- Timer 0 ------------------------------------
  // 1ms-Interrupt @ 3.999.968HZ
  // 3999968/256= 15.624,875Hz=> Prescaler=256
  // 3999968/64= 62.499,5Hz  => Prescaler=64 --> Gewählt
  // 3999968/8= 499.996.0Hz  => Prescaler=8 --> mind 1935 IRQs / Sec
  //Ziel = 1000IRQ/Sec
  // 62.499,5/1000=62,4995  => Einstell CTC
  //--> Schlecht !
  //--------------- Timer 1 ----------------------
  // 1ms-Interrupt @ 3.999.968HZ
  // 3999968/256=    15.624,875 Hz  => Prescaler=256
  // 3999968/ 64=    62.499,5   Hz  => Prescaler=64 
  // 3999968/  8=   499.996,0   Hz  => Prescaler=8 
  // 3999968/  1= 3.999.968,0   Hz  => Prescaler=1 --> mind 61,034 IRQs / Sec
  //Ziel = 1000IRQ/Sec
  // 3999968/1000=3999,968  => Einstell CTC = 4000
  //--> Schlecht !
  TCNT1H=0x00;      //Timer auf 0 Low
  TCNT1L=0x00;
  OCR1A =0x0F9F;      //=4000-(1) -> Laut Formel in Datasheet (S.102) für 1000 IRQs/Sec
  TCCR1B |= (1<<WGM12);  //CTC-Modus
  TCCR1B |= (1<<CS10);  //Prescaler = 1 / Start Timer
  TIMSK |= (1<<OCIE1A);  //Compare - Interrupt Enable
  sei();          //Global IRQ-Enable
  //--------------DCF77 an Port D2 / Int0-------------------
  MCUCR |= (1<<ISC01);  //-->Interrupt bei steigender Pflanke
  MCUCR |= (1<<ISC00);
  GICR |= (1<<INT0);  // Interrupt 0 Enable
  DCF77flag=0;
}

ISR (INT0_vect)
{
  if(DCF77flag==0)  //Steigende Pflanke
  {
    if((Prot_Start>=0)&&(Prot_Start<=57))  //Zurücksetzten am Ende der Minute
    {
      Prot_Start++;
    }    
    if((Prot_Start==58))  //Auswertung der Zeitinformation am ende einer Minute
    {            
//------------ Einstellung der Uhr auf Korrekte zeit (Minuten) -----------------------------
      unsigned short int par= Zeit[21]+Zeit[22]+
                  Zeit[23]+Zeit[24]+
                  Zeit[25]+Zeit[26]+
                  Zeit[27]+Zeit[28];
      if(par%2==0)  //Minute OK --> Patität
      {
        if((Zeit[21]*1+Zeit[22]*2+Zeit[23]*4+Zeit[24]*8)<=9) //Minute OK --> WERT OK
        {
          getZeitinAnzeige(&Anzeige[2],4,21);
          if((Zeit[25]*1+Zeit[26]*2+Zeit[27]*4)<=6)  //Minute OK --> Wert OK
          {
            getZeitinAnzeige(&Anzeige[3],3,25);
            Anzeige[1].dp=1;    //Anzeige Parität der Minute OK
          }
          else
          {
            Anzeige[1].dp=0;    //Anzeige Parität der Minute FALSCH
          }
        }
        else
        {
          Anzeige[1].dp=0;    //Anzeige Parität der Minute FALSCH
        }
      }
      else
      {
        Anzeige[1].dp=0;    //Anzeige Parität der Minute FALSCH
      }
//------------ Einstellung der Uhr auf Korrekte zeit (Stunden) -----------------------------
      par  =  Zeit[29]+Zeit[30]+
          Zeit[31]+Zeit[32]+
          Zeit[33]+Zeit[34]+
          Zeit[35];
      if(par%2==0)  //Minute + Stunde OK
      {
        getZeitinAnzeige(&Anzeige[4],4,29);
          //Anzeige Parität Stunden OK
        if((Zeit[29]*1+Zeit[30]*2+Zeit[31]*4+Zeit[32]*8)<=9) //Minute OK --> WERT OK
        {
          
          if((Zeit[33]*1+Zeit[34]*2)<=2)  //Minute OK --> Wert OK
          {
            getZeitinAnzeige(&Anzeige[5],2,33);
            Anzeige[2].dp=1;  
          }
          else
          {
            Anzeige[2].dp=0;    //Anzeige Parität der Stunden Falsch
          }
        }        
        else
        {
          Anzeige[2].dp=0;    //Anzeige Parität der Stunden Falsch
        }
      }
      else
      {
        Anzeige[2].dp=0;    //Anzeige Parität der Stunden Falsch
      }
//------------ Einstellung der Uhr auf Korrekte zeit (Datum) -----------------------------  
      par=0;
      for(int i=36;i<=58;i++)
      {
        par+=Zeit[i];
      }
      if(par%2==0) //Minute + Stunde + Datum OK
      {
        Anzeige[3].dp=1;      //Anzeige Parität Datum = OK
      }
      else
      {
        Anzeige[3].dp=0;    //Anzeige Parität des Datums Falsch
      }
      //------------------- Anzeige Syncronisation -------------------------------------    
      Prot_Start=-1;            //Reset der Sync-Info
      Anzeige[0].dp=0;          //Anzeige ob Uhr Syncronisiert
    }      

    //Debuging der ms eines 1 Pegels
    //Anzeige[2].Zahl=0;  //einer  min
    //Anzeige[3].Zahl=0;  //Zehner min
    //Anzeige[4].Zahl=0;  //Einer  Std
    
    count1=0;
    MCUCR &= (0<<ISC00);//Einstell Fallende flanke
    DCF77flag=1;
  }
  else        //Fallende Pflanke
  {
    count0=0;
    MCUCR |= (1<<ISC00);//Einstell steigende flanke
    DCF77flag=0;
  }
  //-------Debuging der Pflankenwechsel des DCF77-Signals-------
  //debDCF77Sig()
}

void getZeitinAnzeige(segment *anz, unsigned short int wandl, unsigned short int startbit)
{//Anz   = Zeiger auf Anzeige-Segment
 //wandl = Wie weit gezählt werden soll
   (*anz).Zahl=0;
  for(int i=0;i<wandl;i++)  //Einer_Minute auf Anzeige
  {
    switch (i)
    {
      case 0: (*anz).Zahl+=Zeit[startbit+i]*1;  break;
      case 1: (*anz).Zahl+=Zeit[startbit+i]*2;  break;
      case 2: (*anz).Zahl+=Zeit[startbit+i]*4;  break;
      case 3: (*anz).Zahl+=Zeit[startbit+i]*8;  break;
      default: (*anz).Zahl=100;      break;
    }
  }
}

ISR (TIMER1_COMPA_vect)  //Alle 1ms
{
  volatile static short unsigned int tick;
  Ausgabe(&Anzeige);
  tick++;
  if(tick==1000)  //
  {
    Uhr_Sek();
    tick=0;
  }

  if(DCF77flag==1)    //Zählung der 1-Impulse,
  {
    count1++;
    //--------------Zälung der ms eines 1 Pegels---------------
    //void debDCF77ms()
    if((count0>950)&&(count0<1500))  //Fehler zu kürze 1-Zeit, 0 nicht lange genug für Sync
    {
      Anzeige[4].dp=1;    //Anzeige Erkannter Fehler
    }
    else if ((count0>=1500)&&(count0<=2300))//Erkennen einer neuen Minute
    {
      Anzeige[0].Zahl=0;
      Anzeige[1].Zahl=0;
      Prot_Start=0;
      Anzeige[0].dp=1;
    }
    else if(count0>2300)    //Fehler zu lange 0-Zeit
    {
      Anzeige[4].dp=1;    //Anzeige Erkannter Fehler
    }

  }
  //----------------- Auswertung des Empf-Wert---------------------
  else // Nach dem Ende des 1-Pegels -> Auswertung
  {
    count0++;
    if(count1<70)    //Fehler --> Keine Sync mehr
    {      
      Anzeige[4].dp=1;    //Anzeige Erkannter Fehler
    }
    else if ((count1>=70) && (count1<=160))  //0 Empfangen
    {
      Zeit[Prot_Start]=0;
      Anzeige[5].dp=0;    //0-Empfangen
      Anzeige[4].dp=0;    //Erkannter Fehler Löschen
    }
    else if((count1>160) && (count1<300))  //1 Empfangen
    {
      Zeit[Prot_Start]=1;
      Anzeige[5].dp=1;    //1-Empfangen
      Anzeige[4].dp=0;    //Erkannter Fehler Löschen
    }
    else //(count1>=300)//Fehler --> Keine Sync mehr
    {
      Anzeige[4].dp=1;    //Anzeige Erkannter Fehler
    }
  }
  //---------------Überprüfung der Zeitbasis------------ --> OK = 5000
  //void debTimeBase()
}

void debTimeBase()
{
  static unsigned short int a=0;
  if(a==0)
  {
    DDRD|=0x40;  //Port D.6 = Ausgabe 
    a=1;
    PORTD|=0x40;//Port D.6 = High
  }
  else
  {
    a=0;
    PORTD&=0xAF;//Port D.6 = Low
  }
}

void debDCF77ms()  //Zälung der ms eines 1 Pegels
{
  Anzeige[2].Zahl++;
  if(Anzeige[2].Zahl==10)
  {
    Anzeige[2].Zahl=0;
    Anzeige[3].Zahl++;
    if(Anzeige[3].Zahl==10)
      {
      Anzeige[3].Zahl=0;
      Anzeige[4].Zahl++;
      if(Anzeige[4].Zahl==10)
      {
        Anzeige[4].Zahl=0;
      }
    }
  }
}

void debDCF77Sig() //Debuging der Pflankenwechsel des DCF77-Signals
{
  Anzeige[1].Zahl++;
  if(Anzeige[1].Zahl==10)
  {
    Anzeige[1].Zahl=0;
  }
}

void Ausgabe(segment *segstr)
{        
  static short int Z=0;
  Z++;
  PORTC=0x00;
  PORTA=0xFF;
  switch(Z)
  {
  case 0:  
    PORTC=0x04;    //Einer Sek
    BCDDecode(&segstr[0]);
  break;
  case 1:
    PORTC=0x08;    //Zehne Sek
    BCDDecode(&segstr[1]);
  break;
  case 2:  
    PORTC=0x10;    //Einer Min
    BCDDecode(&segstr[2]);
  break;
  case 3:  
    PORTC=0x20;    //Zehne Min
    BCDDecode(&segstr[3]);
  break;
  case 4:
    PORTC=0x40;    //Einer Std
    BCDDecode(&segstr[4]);
  break;
  case 5:  
    PORTC=0x80;    //Zehne Std  
    BCDDecode(&segstr[5]);
    Z=-1;
  break;
  }
}

void BCDDecode(segment *Wert)
{
  PORTA=0x00;
  if((*Wert).dp==0)  //Kein Punkt
  {
    PORTA|=0x80;  //Punkt löschen
  }
  else
  {
    PORTA&=0x7F;  //Punkt setzen
  }
  switch((*Wert).Zahl)
  {
    case 0: PORTA|= 0x01;  break;
    case 1: PORTA|= 0x37;  break;
    case 2: PORTA|= 0x42;  break;
    case 3: PORTA|= 0x12;  break;
    case 4: PORTA|= 0x34;  break;
    case 5: PORTA|= 0x18;  break;
    case 6: PORTA|= 0x08;  break;
    case 7: PORTA|= 0x33;  break;
    case 8: PORTA|= 0x00;  break;
    case 9: PORTA|= 0x10;  break;
    case 10: PORTA|= 0x70;  break; //°
    case 11: PORTA|= 0x7F;  break; //Leer
    case 12: PORTA|= 0x7E;  break; //Minus
    default: PORTA|= 0x12;  break; //-->3.
  }
}

uhr.h

typedef struct
{
  unsigned short int Zahl;
  unsigned short int dp;
} segment;

unsigned short int Zeit[60];
segment Anzeige[6];
unsigned short int Weckzeit[6];

void Uhr_Sek();

uhr.c

#include <avr/io.h>
#include "Uhr.h" 
#include "delay.h"

void Uhr_Sek()
{
  Anzeige[0].Zahl++;        //Sekunde
  if(Anzeige[0].Zahl==10)      
  {
    Anzeige[0].Zahl=0;      //Zehner_Sek
    Anzeige[1].Zahl++;
    if(Anzeige[1].Zahl==6)    
    {
      Anzeige[1].Zahl=0;    //Einer_Min
    }
  }
}

[Bitflüsterer (Gast)]

Ja, ja. Das mit dem Lesen funktioniert noch nicht so recht. Das sollten 
wir nochmal üben. :-)

Wichtige Regeln - erst lesen, dann posten!
    <snip>
    Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

[Matze (Gast)]

Stimmt, wäre hier sinvoll gewesen ;-)

[Daniel S. (daniel_s49)]

soo viel Code ;-)

Die Parität des Datums funktioniert nie, die Paritäten von Minute und 
Stunde funktionieren immer? Hast du sonst mal die Datums-Paritäten 
(Zeit[58] und die berechnete par) ausgegeben? GgF. mal selber 
nachrechnen, wie der Wert sein sollte und gucken, ob in den Variablen 
überhaupt das richtige steht.

Ansonsten ist das Paritätsbit das letzte der Übertragung. Sowas ist 
gerne mal ein typischer Off-By-One Error. Sprich, du fängst schon mit 
der Auswertung an, obwohl das letzte Bit noch nicht empfangen wurde.
Ich bin jetzt nicht komplett in den Code eingestiegen, aber sagt der 
folgende Schnipsel nicht, dass du zu Beginn des 58. Bit direkt mit der 
Auswertung beginnst? Obwohl du in der anderen ISR erst 100ms später 
herausbekommst, ob das 58. Bit eine 1 oder eine 0 ist?
Als Quickfix vielleicht mal ausprobieren die Auswertung bei 
Prot_Start==0 zu machen oder aber erst bei der fallenden Flanke zu 
reagieren.

  if(DCF77flag==0)  //Steigende Pflanke
  {
    if((Prot_Start>=0)&&(Prot_Start<=57))  //Zurücksetzten am Ende der Minute
    {
      Prot_Start++;
    }    
    if((Prot_Start==58))  //Auswertung der Zeitinformation am ende einer Minute

Unabhängig von deinem Fehler fällt mir grad noch ins Auge, dass Minute 
64 formal korrekt ist. Das <=6 bei der Überprüfung stimmt nicht. (Tritt 
vermutlich eh nie auf und fällt damit auch nie auf)