Ich habe das mal soweit versucht zu realisieren, wie ich konnte. Den Code habe ich angehängt. Leider habe ich noch einen schweren Fehler. Die Frequenz am INT0 stimmt (noch) nicht. Der Fehler liegt wohl in der Umrechnung. Am ICP1 stimmt die Messung. Dann habe ich noch das Problem, dass zwischendurch die Messung am INT0 einen Ausreißer hat.

Code:
//##################################################################
//# MC: Atmega8 16Mhz                                              #
//# Compiler: AVR-GCC 4.1.2 20061115                               #
//# Version: 1.01                                                  #
//# Ports: (TXD) PD1 (3); (ICP1) PB0 (14), (INT0) PD2 (4)          #
//# Funktion: Frequenzzahler, Timer0 an INT0, Timer1 an ICP        #
//##################################################################

#define F_CPU 16000000

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <util/delay.h>
#include "rs232.c"


#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif

volatile unsigned char NumberOverflow0 = 0;  // Anzahl Timer0 Overflows
volatile unsigned char NumberOverflow1 = 0;  // Anzahl Timer1 Overflows 
volatile unsigned int  StartTime0 = 0;        // TCNT0-Wert bei 1.High-Flanke speichern
volatile unsigned int  StartTime1 = 0;        // ICR1-Wert bei 1.High-Flanke speichern
volatile unsigned int  EndTime0 = 0;          // TCNT0-Wert bei 2.High-Flanke speichern
volatile unsigned int  EndTime1 = 0;          // ICR1-Wert bei 2.High-Flanke speichern
volatile unsigned char Update0;               // Flag
volatile unsigned char Update1;               // Flag

//----------------------------------------------------------------------------------
// Flankenauswertung Timer0 INT0
ISR(INT0_vect)
{
 static unsigned char ErsteFlanke0 = TRUE;

 if( Update0 && Update1)
  return;

 if( ErsteFlanke0 )
 {
  StartTime0 = TCNT0;
  NumberOverflow0 = 0;
  ErsteFlanke0 = FALSE;       // Die naechste Flanke ist das Ende der Messung
  }

  else
  {
   EndTime0 = TCNT0;
   Update0 = TRUE;         // Eine vollstaendige Messung. Sie kann ausgewertet werden
   ErsteFlanke0 = TRUE;    // Bei der naechsten Flanke beginnt der naechste Messzyklus
  }
}
//---------------------------------------------------------------------------------
// Flankenauswertung Timer1 ICP1
ISR( TIMER1_CAPT_vect )
{
 static unsigned char ErsteFlanke1 = TRUE;

 if( Update1 && Update0 )
  return;

 if( ErsteFlanke1 )
 {
  StartTime1 = ICR1;
  NumberOverflow1 = 0;
  ErsteFlanke1 = FALSE;       // Die naechste Flanke ist das Ende der Messung
  }

  else
  {
   EndTime1 = ICR1;
   Update1 = TRUE;         // Eine vollstaendige Messung. Sie kann ausgewertet werden
   ErsteFlanke1 = TRUE;    // Bei der naechsten Flanke beginnt der naechste Messzyklus
  }
}
//----------------------------------------------------------------------------------
// Timer0 Overflows zählen
ISR( TIMER0_OVF_vect )
{
  NumberOverflow0++;
}
//----------------------------------------------------------------------------------
// Timer1 Overflows zählen
ISR( TIMER1_OVF_vect )
{
  NumberOverflow1++;
}
//---------------------------------------------------------------------------
int main(void)
{
  double Erg0 = 0.0, Erg1 = 0.0;
  char Wert0[8], Wert1[8];

  initrs232();


  DDRB &= ~(1<<PB0); //PB0 als Eingang
  PORTB |= (1<<PB0); //PB0 Pullup nach Vcc

  DDRD &= ~(1<<PD2); //PD2 als Eingang
  PORTD |= (1<<PD2); //PD2 Pullup nach Vcc

  GICR |= (1<<INT0);  //INT0 aktivieren
  MCUCR |= (1<<ISC00) | (1<<ISC01); //pos.Flanke an INT0

  //Timer0 8bit
  TCCR0 |= (1<<CS00); // Kein Prescaling, 
  TIMSK |= (1<<TOIE0); //Overflow Interrupt aktiviert

  //Timer1 16bit, 
  TCCR1B |= (1<<CS10) | (1<<ICES1); //Kein Prescaling 
  TIMSK |= (1<<TICIE1) | (1<<TOIE1); //pos. Flanke, Overflowinterrupt aktivieren

  sei(); //globale Interrupts aktivieren

  while(1)
    {


	if( Update0 && Update1) //Auf vollständige Messung prüfen
  	{

		Erg0 = (NumberOverflow0 * 256) + EndTime0 - StartTime0;
		Erg1 = (NumberOverflow1 * 65536) + EndTime1 - StartTime1;
		Erg0 = F_CPU / Erg0;
		Erg1 = F_CPU / Erg1;

		dtostrf( Erg0, 5, 3, Wert0 );
		dtostrf( Erg1, 5, 3, Wert1 );

		uart_puts("Frequenz an INT0: ");
		uart_puts( Wert0 );
		uart_puts(" Hz ");
		
		uart_puts("Frequenz an ICP: ");
		uart_puts( Wert1 );
		uart_puts(" Hz\n");

		Update0 = FALSE;
		Update1 = FALSE;
		
        }
    }
}