DCF77-Signalauswertung mit ATmega32

[Jens K. (mister232)]

Hallo Leute,

versuche mich gerade daran das Signal eines DCF77-Moduls von Reichelt 
auszuwerten und die aktuelle Zeit per serielle Schnittstelle an einen 
Computer zu senden. Am PC empfange ich auch etwas, nur leider nicht die 
aktuelle Zeit. Er zählt einfach die Sekunden hoch und zeigt mir den 
aktuellen Stand an. Hier mal die main-Datei und die Datei in welcher das 
Signal ausgewertet wird:

/*
 * main.c
 *
 * Created: 27.02.2014 13:27:29
 *  Author: Jens
 *
 * This program receives the DCF77 signal from a DCF77-Module from Reichelt and evaluates the
 * received data. The calculated time will be transmitted to a computer via UART. The program
 * is written for an ATmega32 device
 *
 */ 

#include "global.h"
#include "uart.h"
#include "DCF77.h"
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
  char msgBuffer[100];
  
  // Initialize the UART-Interface with 4800 baud
  init_UART(4800);
  strcpy(msgBuffer, "*********** DCF77-Clock **************\n");
  uart_write_msg(msgBuffer,strlen(msgBuffer));
  
  // Enable global interrupts
  sei();
  
  // Start DCF77 clock
  strcpy(msgBuffer, "Starting clock...");
  uart_write_msg(msgBuffer,strlen(msgBuffer));
  Start_Clock();
  strcpy(msgBuffer, "Done\n");
  uart_write_msg(msgBuffer,strlen(msgBuffer));
  
  while(1)
  {
    // Transmit actual time to the computer
    sprintf(msgBuffer, "Time: %i:%i:%i \n", hh, mm, ss);
    uart_write_msg(msgBuffer,strlen(msgBuffer));
    
    // Wait
    _delay_ms(1000);
  }
  
  return 0;
}

/*
 * DCF77.c
 *
 * Created: 27.02.2014 00:10:17
 *  Author: Jens
 *
 * This file includes control functions for the use of a DCF77 module from Reichelt
 *
 */ 

#include "DCF77.h"
#include "global.h"
#include <avr/io.h>
#include <avr/interrupt.h>

volatile unsigned char ss   = 0;   // Seconds
volatile unsigned char mm   = 0;   // Minutes
volatile unsigned char hh   = 0;   // Hours

// Bit-counter for RX bit
volatile unsigned char rx_bit_counter = 0;

// 64 Bit, for DCF77 used 59 Bits
volatile unsigned long long dcf_rx_buffer = 0;

// Help-counter for seconds
volatile unsigned int h_ss = 0;

// Help-variable for hour-change
volatile unsigned int h_hh = 0;

// Timer1 overflow Interrupt, triggered by 59. second or no received DCF77 signal
ISR(TIMER1_OVF_vect)
{
  struct  DCF77_Bits *rx_buffer;
  rx_buffer = (struct DCF77_Bits*)(char*)&dcf_rx_buffer;
  
  // Reset timer
  TCNT1 = 65535 - (F_CPU / 1024);
  
  // If all 59 Bits and the parity's are correctly received, set clock to DCF77 signal
  if ((rx_bit_counter == 59) && (flags.parity_P1 == rx_buffer->P1) && (flags.parity_P2 == rx_buffer->P2) && (flags.parity_P3 == rx_buffer->P3))
  {
    // Calculate minutes BCD to HEX
    mm = rx_buffer->Min - ((rx_buffer->Min / 16) * 6);
    
    if(mm != 0)
    {
      mm--;
    }
    else
    {
      mm = 59; 
      h_hh = 1;
    }
    
    // Calculate hours BCD to HEX
    hh = rx_buffer->Hour - ((rx_buffer->Hour / 16) * 6);

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

    // Reset seconds to zero
    ss = 59;
    flags.dcf_sync = 1;
  }
  else
  {
    // Manually set the clock 
    Add_one_Second();
    flags.dcf_sync = 0;
  }
  
  // Reset the RX Bit-Counter
  rx_bit_counter = 0;
  // Clear the RX buffer
  dcf_rx_buffer = 0;
}

// Interrupt on INT0, DCF77 Module receives time information
ISR(INT0_vect)
{
  // Evaluate pulse width
  if(INT0_CONTROL == INT0_RISING_EDGE)
  {
    flags.dcf_rx ^= 1;
    
    // Calculate second help-counter
    h_ss = h_ss + TCNT1 - (65535 - (F_CPU / 1024));
    // Reset timer
    TCNT1 = 65535 - (F_CPU / 1024);
    
    // Check if a second is over
    if(h_ss > (F_CPU / 1024 / 100 * 90)) //90% from 1 second
    {
      Add_one_Second();
      // Reset second help-counter
      h_ss = 0;
    }
    
    // Next interrupt with falling edge
    INT0_CONTROL = INT0_FALLING_EDGE;
  }
  else
  {
    // Read pulse width from rising edge to falling edge
    unsigned int pulse_wide = TCNT1;
    // Reset timer
    TCNT1 = 65535 - (F_CPU / 1024);
    // Calculate second help-counter
    h_ss = h_ss + pulse_wide - (65535 - (F_CPU / 1024));
    
    //Safe parity:
    // Begin area P1/P2/P3
    if((rx_bit_counter ==  21) || (rx_bit_counter ==  29) || (rx_bit_counter ==  36))
    {
      flags.parity_err = 0;
    }
    // Safe P1
    if(rx_bit_counter ==  28)
    {
      flags.parity_P1 = flags.parity_err;
    }
    //Safe P2
    if(rx_bit_counter ==  35)
    {
      flags.parity_P2 = flags.parity_err;
    }
    //Safe P3
    if(rx_bit_counter ==  58)
    {
      flags.parity_P3 = flags.parity_err;
    }
    
    // Check if a 0 or 1 is received
    //0 = 100 ms
    //1 = 200 ms
    // > 150ms (15% from 1 second -> 150ms)
    if(pulse_wide > (65535 - (F_CPU / 1024) / 100 * 85))
    {
      // Write a 1 into the dcf_rx_buffer at position rx_bit_counter
      dcf_rx_buffer = dcf_rx_buffer | ((unsigned long long) 1 << rx_bit_counter);
      //Toggle Help-Parity
      flags.parity_err = flags.parity_err ^ 1;
    }
    
    // Next interrupt with rising edge
    INT0_CONTROL = INT0_RISING_EDGE;
    // Inkrement RX Bit-Counter
    rx_bit_counter++;
  }
}

// Function to add a second to the actual time value
void Add_one_Second (void)
{
  ss++;
  
  // Check if a minute is done
  if (ss == 60)
  {
    ss = 0;
    mm++;
    
    // Check if a hour is done
    if (mm == 60)
    {
      mm = 0;
      hh++;
      
      // Check if the day is finished
      if (hh == 24)
      {
        hh = 0;
      }
    }
  }
};

// Function to initialize and start the timer
void Start_Clock (void)
{
  // Enable interrupt on DCF77 with rising edge
  DCF77_INT_ENABLE();
  INT0_CONTROL = INT0_RISING_EDGE;
  
  // Interrupt overflow enable
  TIMSK1 |= (1 << TOIE1);
  // Set prescaler to 1024
  TCCR1B |= (1<<CS10 | 0<<CS11 | 1<<CS12);
  TCNT1 = 65535 - (F_CPU / 1024);
}

Und der Header zur Signalauswertung:

/*
 * DCF77.h
 *
 * Created: 27.02.2014 10:20:46
 *  Author: Jens
 */ 


#ifndef DCF77_H_
#define DCF77_H_

volatile unsigned char ss;  // Seconds
volatile unsigned char mm;  // Minutes
volatile unsigned char hh;  // Hours

extern void Start_Clock (void); // Function to start the DCF77-Clock
extern void Add_one_Second (void); // Function to add one second to the actual time

// 64 Bit, for DCF77 used 59 Bits
volatile unsigned long long dcf_rx_buffer;
// RX Pointer (Counter)
volatile extern unsigned char rx_bit_counter;
// Help-Counter for seconds
volatile unsigned int h_ss;

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

//Structure of the 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 for minutes
  unsigned char P1      :1  ;// Parity minutes
  unsigned char Hour      :6  ;// 6 Bits for hours
  unsigned char P2      :1  ;// Parity hours
  unsigned char P3      :1  ;// Parity from P2
};

struct
{
  volatile char parity_err        :1  ;// Help Parity
  volatile char parity_P1          :1  ;// Calculated Parity P1
  volatile char parity_P2          :1  ;// Calculated Parity P2
  volatile char parity_P3          :1  ;// Calculated Parity P3
  volatile char dcf_rx          :1  ;// A impulse is received
  volatile char dcf_sync          :1  ;// The clock was synchronized in the last minute
}flags;

#endif /* DCF77_H_ */

Ich hoffe ihr könnt mir weiterhelfen ;)

Gruß
Mister232

[Karl H. (kbuchegg)]

Du hast eine UART und die funktioniert auch.
Da würde ich doch glatt mal anfangen, den Mega nicht die aktuelle Zeit 
ausgeben zu lassen, sondern an strategisch günstigen Positionen ein paar 
der ermittelten Kennwerte in der ISR.
Anfangen würde ich damit, mir die ermittelten Pulslängen ausgeben zu 
lassen, bzw. ob der Mega überhaupt in die ISR reinkommt.

Du hast eine UART. Benutze sie!
Man kann und darf die benutzen um sich nicht nur die Endergebnisse 
ausgeben zu lassen, sondern auch Zwischenergebnisse bzw. auch mal ein 
oder 2 Sonderzeichen, mit denen man verfolgen kann, ob bestimmte 
Programmpfade genommen werden oder nicht.

[Jens K. (mister232)]

Also ich habe gerade mal ausprobiert eine LED blinken zu lassen wenn ich 
in die INT0 ISR rein gehe. Beim einschalten blinkt sie einmal, dann 
nicht mehr. Könnte es sein das ich keinen Empfang habe? Habe es schon an 
verschiedenen Positionen ausprobiert, mit dem selben Ergebnis.

[Martin S. (tungl)]

Ohne jetzt deinen Code genauer angeschaut zu haben: Hast du den Ausgang 
Deines Reichelt-Moduls direkt an den Mega32 gehängt? Hatte ich naemlich 
damals auch zuerst so gemacht, aber das Teil ist mega-empfindlich, 
sodass es direkt gar nicht funktioniert hat.

[Jens K. (mister232)]

Ja, ist direkt damit verbunden. Wie hast du es denn dann gemacht?

[Martin S. (tungl)]

Ok, so ging's bei mir auch nicht. Anscheinend ist das Modul sogar dazu 
zu schwach, genug Strom fuer den internen Pull-Up des ATMega zu liefern. 
Hatte da damals einen Transistor dazwischen gesetzt, danach ging es. 
Genaue Schaltung bzw. Dimensionierung hab ich leider nicht mehr im Kopf.

[Stefan F. (Gast)]

>  Könnte es sein das ich keinen Empfang habe?

Das kannst Du mit einer LED direkt am DC-Modul (eventuell über einen 
Transistor zur Verstärkung) ganz schnell herausfinden. Die Kontroll-LED 
würde ich für immer an der Schaltung dran lassen, kann immer mal 
nützlich sein. Man sieht sofort, ob Empfang vorhanden ist und ob er gut 
genug ist. Bei schlechtem Empfang flackert die LED unregelmäßig.

[Jens K. (mister232)]

So: Ich habe das Reichelt-Modul jetzt durch ein wesentlich stabileres 
Modul von ELV ausgetauscht. Nun blinkt die LED, welche mir signalisiert 
das ein INT0 Interrupt aufgetreten ist, etwa im Sekundentakt.

Ich lasse mir nun im Terminal die Pulslänge ausgeben, doch leider 
erscheinen immer nur Werte um 6300 rum (+/- 150). Das heißt also das ich 
nur 1sen empfange?

[Jens K. (mister232)]

Hat vielleicht jemand nen Link zu nehm funktionierenden Code?

[Karl H. (kbuchegg)]

Nimms wie ein Mann.
Du hast viel zu viel Code auf einmal geschrieben und weisst jetzt nicht, 
wo du mit Fehlersuche anfangen sollst.

Daher zurück an den Anfang und noch mal von vorne.
Aber diesmal mit weniger Aufwand.

Erste Version
Interrupt auf beide Flanken, Timer durchlaufen lassen und in der ISR die 
Timerwerte ausgeben

ISR(INT0_vect)
{
  static uint16t last;
  uint16_t difference;

  difference = last - TCNT1;
  last = TCNT1;

  uart_put_uint( difference );
}

(100ms sollten eigentlich reichen, dass du in der ISR einen uint in 
ASCII Form ans Terminal schicken kannst, auch wenn man normalerweise 
keine Ausgaben in einer ISR macht. Das darf hier nicht zu lange dauern, 
denn die ISR muss fertig sein, ehe die nächste Flanke kommt)


Und dann siehst du dir mal die ermittelten Werte an.


Schlimmsten Falls müsste man sich die Grenzwerte ausrechnen und durch 
ein paar Vergleiche mit diesen Grenzwerten dann nur ein Kenn-Zeichen 
ausgeben

    if( difference < Border_for_Low )
       uart_putc( '0' );
    else if( difference < Border_for_Second_Marker )
       uart_putc( '1' );
    else
       uart_putc( '\n' );

Die tatsächlichen Werte wären allerdings besser. Kein zusätzlicher 
Schnickschnack. Da muss kein Text dabei stehen. Zahl und ein 
Leerzeichen, damit du die Zahlen richtig lesen kannst - das muss 
reichen. Du hast hier nicht die Zeit um da einen halben Roman 
hinzuschreiben.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> reichen. Du hast hier nicht die Zeit um da einen halben Roman
> hinzuschreiben.

Alternativ ginge noch, den Portpin abzufragen (nur weil der einen 
Interrupt auslöst, heißt das ja nicht, das man den nicht per PINx 
Register abfragen kann).

Die Ausgabe findet nur dann statt, wenn der Pin einen 0 Pegel hat (*). 
Denn dann ist der Puls vorbei und du hast theoretisch im schlimmsten 
Fall mindestens 0.8 Sekunden bis der nächste Puls beginnt. Und das 
sollte dann dicke reichen.

(*) unter der Annahme, dass das Modul active High Pulse liefert. Aber 
das müsstes du an der LED schon gesehen haben, ob die active High oder 
active Low sind.

[Jens K. (mister232)]

Habe jetzt mal ne abgespeckte Version gebaut:

/*
 * main.c
 *
 * Created: 11.03.2014 18:56:52
 *  Author: Jens
 */ 


#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <string.h>
#include "global.h"
#include "uart.h"
#include <util/delay.h>

char msgBuffer[100];

ISR (INT0_vect)
{
  // Show timer value
  sprintf(msgBuffer, "TCNT1: %u \n\r", TCNT1);
  uart_write_msg(msgBuffer,strlen(msgBuffer));

  // Reset timer counting register
  TCNT1 = 0x00;
}



int main(void)
{
  // Init uart
  init_UART(9600);

  // enable INT0
  GICR |= (1<<INT0);  

  // INT0 for both, rising and falling edge
  MCUCR |= (0<<ISC11) | (1<<ISC10);
  // Prescaler 1024
  TCCR1B |= (1<<CS12) | (1<<CS10);

  // Global enable interrupts
  sei();

  while(1);
  {

  }
  
  return 0;
}

Als Ausgabe kommt nur sehr schnell hintereinander 0 und manchmal 1. Ich 
habe zusätzlich noch eine LED direkt an den Ausgang des DCF-Moduls 
gehängt, diese blinkt nun im Sekundentakt (Signal scheint also okay zu 
sein)

[Karl H. (kbuchegg)]

Dann schaltest du jetzt erst mal den Pin auf Eingang.

Nur weil du dein INT0 aktiviert hast, heisst das noch lange nicht, dass 
der entsprechende Pin damit automatisch auf Input gestellt ist.

[Jens K. (mister232)]

Noch keine Veränderung:

TCNT1: 0 und manchmal 1

[Bernd (Gast)]

Hallo Jens,
da Du den Zaehlerwert des Timer1 ausgibst, und der der nur 0 oder 1 ist,
würde ich mal testen, was rauskommst , wenn Du den Teilerfaktor von 
Timer1 änderst (z.B. 64). Dann muss der Zaehler doch weiterlaufen als 
bis 1.
Wie hoch ist denn Dein Mikrocontrollertakt ?.

Das DCF-Signal auswerten ist nicht das Problem, sonder ein ungestörtes 
Signal aus dem DCF Modul hin zu bekommen, wenn der Controller daran 
angeschlossen ist. Mit LED kann man es manchmal nicht sehen, besser mit 
Oszi.
Schau Dir mal hier die Info zu DCF von der WORDCLOCK an.

Gruß
Bernd

[André C. (clausi)]

Hallo,

ich habe mal aus einer meiner Rollosteuerungen die relevanten Teile zur 
DCF-Zeit rausgeholt. Ich hoffe ich habe nichts vergessen. Lief 
eigentlich sehr gut mit einem Atmega8.

Habe gerade keine Zeit mich weiter reinzulesen, ich hoffe es reicht 
erstmal.

PS: das stammt noch aus meinen µC Anfangszeiten, also sorry für 
eventuelle Formfehler und sonstiges... ;-)






bool clock[60];
int clock_bit;
int cnt_clock;
bool first_clock=0;
bool clock_ok;

unsigned long uhrzeit;



//negative Flanke
  bool fl_neg(bool Variable, bool* flankenmerker)
  {
    int return_val=0;

    if (Variable==1)
    {
      (*flankenmerker)=1;
    }

    if ((Variable==0) && ((*flankenmerker)==1))
    {
      return_val=1;
      (*flankenmerker)=0;
    }

    return return_val;
  }






int main(void)
{

  DDRB=0xFE;
  PORTB=0x01;

  DDRD = 0x00;
  PORTD = 0xFF;

// Timer 1 konfigurieren
  TCCR1B = (1<<WGM12);
  TCCR1B |= (1<<CS11) | (1<<CS10); // CTC Modus
  // ((8000000/64)/1000) = 125
  OCR1A = 125-1;

  // Compare Interrupt erlauben
   TIMSK |= (1<<OCIE1A);

  // Global Interrupts aktivieren
  sei();


//Zyklisches Programm
    while (1)
  {

    if ((PINB & 0x01)>0)
    {
      PORTB |= (1<<PB1);
    }
    else
    {
      PORTB &= ~(1<<PB1);
    }

    if (first_clock)
    {
      PORTB &= ~(1<<PB2);
    }
    else
    {
      PORTB |= (1<<PB2);
    }

    if (clock_ok)
    {
      PORTB &= ~(1<<PB4);
    }
    else
    {
      PORTB |= (1<<PB4);
    }


/Uhrzeit decodieren
    if (clock_ok==1)
    {
      sekunde=0;
      minute=0;
      stunde=0;
      wochentag=0;


      for (int i=0; i<4; i++)
      {
        minute=minute+((clock[21+i])*(pot(2,i)));
        stunde=stunde+((clock[29+i])*(pot(2,i)));
      }

      for (int i=0; i<3; i++)
      {
        minute=minute+(((clock[25+i])*(pot(2,i)))*10);
        wochentag=wochentag+((clock[42+i])*(pot(2,i)));
      }

      for (int i=0; i<2; i++)
      {
        stunde=stunde+(((clock[33+i])*(pot(2,i)))*10);
      }

      clock_ok=0;
      cnt_clock=0;
      first_clock=0;

      wochentag--;

      time_to_long(&uhrzeit,stunde, minute, sekunde);
    }
  }
}




//Interrupt für Zeit
ISR (TIMER1_COMPA_vect)
{


//Funkzeit
  if (clock_ok==0)
  {
    cnt_clock++;

    if (fl_neg((PINB & 0x01)==1, &flanke.clock_input))
    {
      if (cnt_clock>1200)
      {
        if (first_clock)
        {
          clock_ok=1;
        }

        clock[0]=1;
        clock_bit=0;
        first_clock=1;
      }
      else
      {
        if (first_clock)
        {
          if (clock[clock_bit-1]==0)
          {
            if (cnt_clock<1050)
            {
              clock[clock_bit]=0;
            }

            if (cnt_clock>1050)
            {
              clock[clock_bit]=1;
            }
          }

          if (clock[clock_bit-1]==1)
          {
            if (cnt_clock>950)
            {
              clock[clock_bit]=1;
            }

            if (cnt_clock<950)
            {
              clock[clock_bit]=0;
            }
          }
        }
      }

      cnt_clock=0;
      clock_bit++;

    }

    if (clock_bit>60)
      {
        clock_bit=0;
      }
    }

}

[Jens K. (mister232)]

Wenn ich den prescaler auf 64 setze dann kommt er bis 2 mit dem Zählen. 
Der ATmega arbeitet mit einem externen 8MHz Quarz. Am Oszi sehen die 
einkommenden Signale ganz ordentlich aus, ich kann sie aber nicht 
vernünftig anschauen, da mein Oszi kaputt ist und nicht richtig 
triggert.

[Jens K. (mister232)]

Es lebt!
Ich habe im Internet den Tipp gefunden, dass das ELV DCF-Modul wohl ein 
invertiertes Signal liefert. Nun habe ich die steigende und fallende 
Flanke in meinem Code umgedreht und... tada... alles funktioniert. Er 
synchronisiert sich und liefert die aktuelle Zeit.

Danke für eure Hilfe!