DCF77-Signalauswertung mit ATmega32

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.

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.

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.

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

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.

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?

Hat vielleicht jemand nen Link zu nehm funktionierenden Code?

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

1

ISR(INT0_vect)

2

{

3

  static uint16t last;

4

  uint16_t difference;

5

6

  difference = last - TCNT1;

7

  last = TCNT1;

8

9

  uart_put_uint( difference );

10

}

(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

1

    if( difference < Border_for_Low )

2

       uart_putc( '0' );

3

    else if( difference < Border_for_Second_Marker )

4

       uart_putc( '1' );

5

    else

6

       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 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.

Habe jetzt mal ne abgespeckte Version gebaut:

1

/*

2

 * main.c

3

 *

4

 * Created: 11.03.2014 18:56:52

5

 *  Author: Jens

6

 */ 

7

8

9

#include <avr/io.h>

10

#include <avr/interrupt.h>

11

#include <stdio.h>

12

#include <string.h>

13

#include "global.h"

14

#include "uart.h"

15

#include <util/delay.h>

16

17

char msgBuffer[100];

18

19

ISR (INT0_vect)

20

{

21

  // Show timer value

22

  sprintf(msgBuffer, "TCNT1: %u \n\r", TCNT1);

23

  uart_write_msg(msgBuffer,strlen(msgBuffer));

24

25

  // Reset timer counting register

26

  TCNT1 = 0x00;

27

}

28

29

30

31

int main(void)

32

{

33

  // Init uart

34

  init_UART(9600);

35

36

  // enable INT0

37

  GICR |= (1<<INT0);  

38

39

  // INT0 for both, rising and falling edge

40

  MCUCR |= (0<<ISC11) | (1<<ISC10);

41

  // Prescaler 1024

42

  TCCR1B |= (1<<CS12) | (1<<CS10);

43

44

  // Global enable interrupts

45

  sei();

46

47

  while(1);

48

  {

49

50

  }

51

52

  return 0;

53

}

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)

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.

Noch keine Veränderung:

TCNT1: 0 und manchmal 1

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

}

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.

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!