Atmega2560 Timerproblem

[RobertmcDonald (Gast)]

Hallo ich will meinen Timer vom Atmgea auf ein externes Uhrenquarz 
umstellen. Davor hatte ich den Timer auf TIMER1_COMPA_vect verglichen 
und er hat funktioniert sobald ich auch ohne den Uhrenquarz umstelle 
funzt das ganze nicht mehr. Hier der Code (Die alte Variante 
auskommentiert):

ISR(TIMER1_OVF_vect)//Interruptroutine für Uhrzeit
{
//... BLAbLA
}

void Time_Init(void)
{
Message_Out_Str("A",1);
/*
//Prescaler Variante
//CTC Modus
TCCR1A &= ~(1<<WGM10);
TCCR1A &= ~(1<<WGM11);
TCCR1B |= (1<<WGM12);
TCCR1B &= ~(1<<WGM13);

//Output Compare A true
TCCR1C |= (1<<FOC1A);

//Prescaler auf 1024
TCCR1B |= (1<<CS12);
TCCR1B &= ~((1<<CS10)|(1<<CS11));

//Output Compare auf 100ms setzen
//16000000/(256)*1000/1000=6250
//256 Prescaler, 1000 da jede 100ms auslösen soll, :1000 umrechnung von 
ms auf s
//125 sehalb damit Erg. gerade --> Fehler klein halten
OCR1A=6250;

//Output Compare Interrupt aktivieren
TIMSK1 |= (1<<OCIE1A);
*/

//Normaler Modus
TCCR1A &= ~(1<<WGM10);
TCCR1A &= ~(1<<WGM11);
TCCR1B &= ~(1<<WGM12);
TCCR1B &= ~(1<<WGM13);

//Mit Uhrenquarz (rising edge)
TCCR1B |=((1<<CS10)|(1<<CS11)|(1<<CS12));


//Output Compare Interrupt aktivieren
TIMSK1 |= (1<<TOIE1);
//Rest vorsichtshalber deaktivieren
TCCR1C &= ~((1<<FOC1A)|(1<<FOC1B)|(1<<FOC1C));
TIMSK1 &= ~((1<<OCIE1A)|(1<<OCIE1B)|(1<<OCIE1C));

//Zähler am Anfang auf 0 setzen
TCNT1=0;

sei();//Interrupts an

zeit_h = ZEIT_DEFAULT/60;
zeit_m = ZEIT_DEFAULT%60;
}

[RobertmcDonald (Gast)]

Das wäre viell. auch noch wichtig obwohl es ja etwas mit dem Interrupt 
zu tun hat:

#include <avr/interrupt.h>
#include <string.h>
#include <stdlib.h>

#include "zeit.h"



#define F_CPU 16000000        //Prozessortakt      //CPU-Takt im MHz

volatile uint8_t  zeit_h,zeit_m,zeit_s, zeit_ms_128;  //Zahlenbereich 
0-255

Sowie die Header Datei:
////////////////////////////////////////////////
#ifndef ZEIT_H_
#define ZEIT_H_

#include <avr/io.h>

uint8_t Set_Time(uint8_t stunden,uint8_t minuten);
uint8_t Check_Time(uint16_t minuten);
uint16_t Get_Time_Minuten();
void Get_Timestamp(char *s);

#endif

[Helfer (Gast)]

main.c

#ifndef F_CPU
#define F_CPU 16000000UL
#endif /* F_CPU */

#include <avr/io.h> // ++
#include <avr/interrupt.h>
#include <string.h>
#include <stdlib.h>
#include "zeit.h"

#define UHRENQUARZ 1

//Zahlenbereich 0-255 ausreichend
volatile uint8_t zeit_h, zeit_m, zeit_s, zeit_ms_128;  

// Aufruf alle 
//   100ms bei Takt F_CPU
//   125ms bei Takt Uhrenquarz
ISR(TIMER1_COMPA_vect)//Interruptroutine für Uhrzeit
{
  //... BLAbLA
}

void Time_Init(void)
{
  /* CTC Variante
  Output Compare auf 100ms setzen

  Fall #1: Clock Source = F_CPU
  Takte / s bei Prescaler 1 = 16000000
  Takte / s bei Prescaler PRESCALER = 16000000 / PRESCALER 
  Takte / 100ms bei Prescaler PRESCALER = 16000000 / PRESCALER / 10

  Prescaler OCR1A+1  Anm. 
  =======================================================
  1         1600000  Nicht benutzbar weil 16-Bit Overflow
  8          200000  Nicht benutzbar weil 16-Bit Overflow
  16         100000  Nicht benutzbar weil 16-Bit Overflow
  64          25000  Benutzbar
  256         4494,4 Bruch ist ungünstig
  1024        1562,5 Bruch ist ungünstig
  => Optimale Einstellung: PRESCALER 64 (CS10 und CS11) 

  Fall #2: Clock Source = Uhrenquarz
  PRESCALER = 1
  Clock on falling Edge: 

  Takte / s bei Prescaler 1 = 32768
  Takte / s bei Prescaler PRESCALER = 32768 / 1 = 32768
  Takte / 100ms bei Prescaler PRESCALER = 32768 / 10 = 3276,8

  100ms lassen sich nicht mit einer geraden Zahl von Takten erreichen!
  was geht: 
  IRQ alle 125ms (32768/8 = 4096) oder alle 62,5ms (32768/16 = 2048) 
  */ 

#if UHRENQUARZ
  // COMPA alle 125 ms
  OCR1A = (32768U/8)-1; // Fall #2: Clock Source = Uhrenquarz
#else
  // COMPA alle 100 ms
  OCR1A = ((F_CPU/64)/10)-1; // Fall #1: Clock Source = F_CPU
#endif /* UHRENQUARZ */

  TCCR1A = 0;
#if UHRENQUARZ
  //CTC Modus #5 (WGM12) und 
  //External clock source on Tn pin. Clock on falling edge
  TCCR1B = (1<<WGM12) | (1<<CS12)| (1<<CS11);
#else
  //CTC Modus #5 (WGM12) und 
  //Prescaler auf 64
  TCCR1B = (1<<WGM12) | (1<<CS11)| (1<<CS10);
#endif /* UHRENQUARZ */

  //Output Compare Interrupt aktivieren
  TIMSK1 |= (1<<OCIE1A);
}

int main(void)
{
  Time_Init();
  sei(); 
  while(1) {
  }
}