AVR Freaks

#include 
#define F_CPU 7372800
#include 
#include 
#define BAUDRATE 115200
//calculate UBRR value
#define UBRRVAL 3//((F_CPU/(BAUDRATE*16))-1) (9600bps 47ubbr) (115200 3ubbr)

void USART_Init()
{
    //Set baud rate
	UBRR0L=(uint8_t)UBRRVAL; //low byte register
	UBRR0H=(UBRRVAL>>8);	 //high byte register
	//Set data frame format:
	UCSR0C &=~(1<<UMSEL01)|(1<<UMSEL00); //asynchronous mode
	UCSR0C &=~(1<<UPM01)|(1<<UPM00);     //No parity
	UCSR0C &=~(1<<USBS0);                //1 stop bit
	UCSR0C  |=(1<<UCSZ01)|(1<<UCSZ00);   //8 bit size
    UCSR0B &=~(0<<UCSZ02);               //8 bit size
	UCSR0B |=(1<<RXEN0)|(1<<TXEN0);      //Enable Receiver & Transmitter
//	UCSR0B |=(1<<RXCIEO)|(1<<TXCIEO);	
}

void USART_SendByte(uint8_t u8Data)
{
    while((UCSR0A&(1<<UDRE0)) == 0); // Wait if a byte is being transmitted   
    UDR0 = u8Data; // Transmit data
}

void ICP_Init(void)
{
	//ICP1 enable
	TIMSK1 |=(1<<ICIE1); //enable input capture interrupt
	TCCR1B |=(1<<ICNC1)|(1<<ICES1)|(1<<CS11); //Noise canceller, rising edge, with 8 prescaler
	TIFR1 |= (1<<ICF1); //clear interrupt-flag
}

volatile uint16_t PulseWidth; //Kept in memory, not forgotten until re-written

void Capture(void)
{
	cli();
	PulseWidth = ICR1;
	USART_SendByte(PulseWidth);
	USART_SendByte(PulseWidth>>8);
	TCNT1 = 0;
	sei();
}

ISR(TIMER1_CAPT_vect)
{
	Capture();
}

int main(void)
{
	USART_Init();
	ICP_Init();
	sei();
	for(;;)
	{
	}
}

The Input Capture Flag (ICF1) is set at
the same system clock as the TCNT1 value is copied into ICR1 Register. If enabled (ICIE1 = 1),
the Input Capture Flag generates an Input Capture interrupt. The ICF1 Flag is automatically
cleared when the interrupt is executed.

volatile uint16_t PulseWidth;

ISR(TIMER1_CAPT_vect)
{
   //Do i even need to declear this ISR?
}

int main(void)
{
   USART_Init();
   ICP_Init();
   sei();
   for(;;)
   {
      if((TIFR1 & (1<<ICF1)) != 0)
      {
      cli();
      PulseWidth = ICR1;
      USART_SendByte(PulseWidth);
      USART_SendByte(PulseWidth>>8);
      TIFR1 = (1 << ICF1); //Clears the flag.
      sei();
      }
   }
}

volatile uint16_t PulseWidth; //Kept in memory, not forgotten until re-written
volatile int NewCapture = 0;

ISR(TIMER1_CAPT_vect)
{
   NewCapture = 1;
}

int main(void)
{
   USART_Init();
   ICP_Init();
   sei();
   for(;;)
   {
      if(NewCapture != 0)
      {
      cli();
      PulseWidth = ICR1;
      USART_SendByte(PulseWidth);
      USART_SendByte(PulseWidth>>8);
      NewCapture = 0; //Clears the flag.
      TCNT1 = 0;
      sei();
      }
   }
}

Why waste two bytes on a flag when one would do?

Also be cautious about passing anything but 8bits between ISR and main(). While a 0/1 flag doesn't matter if you start passing numeric values and the variable is larger than 8bits you will need atomicity protection. This is why it's always a good idea to stick to 8bits when you can.

int NewCapture = 0;

volatile uint16_t PulseWidth; //Kept in memory, not forgotten until re-written
volatile int NewCapture = 0;

ISR(TIMER1_CAPT_vect)
{
   NewCapture = 1;
}

int main(void)
{
	USART_Init();
	ICP_Init();
	sei();
	for(;;)
	{
		if (TCNT1 != 65535) //Dont send value or it will be corrupt.
		{
			if(NewCapture != 0)
     		{
			cli();
			PulseWidth = ICR1;
			USART_SendByte(PulseWidth);
			USART_SendByte(PulseWidth>>8);
			NewCapture = 0; //Clears the flag.
			TCNT1 = 0;
			sei();
			}
		}
	}
}

Why do you test TCNT1? I don't think it will have the effect you want. You need to add a timeout methinks. Read up on the timer compare feature. Enable a compare channel . In the compare isr, reload startup_count and disable the compare interrupt. In the capture isr, have OCR1x= ICR1+ timeout in ticks and enable the compare interrupt.

ISR (TIMER1_COMPA_vect)
{
	startup_count = 2;
	TIMSK1 &=~ (1<<OCIE1A); //Disable Interrupt
}

ISR(TIMER1_CAPT_vect)
{
	static uint16_t prev,curr;

	curr = ICR1;
	PulseWidth =  curr - prev;
	prev = curr;
	if (startup_count)
	{
		startup_count--;
	}
	else
	{
		Capture = 1;
	}
	OCR1A = ICR1 + timeout in ticks??
	TIMSK1 |= (1<<OCIE1A); //Enable Interrupt
}

What timeout do you want?

You can count overflows if you want a greater timeout value but you want to count more than one overflow - reason being if your last capture is close to 65535, then you'll timeout almost immediately.

volatile uint16_t PulseWidth;
volatile uint8_t Count;
volatile uint8_t Capture;

ISR(TIMER1_OVF_vect)
{
	Count = 0;
}

ISR(TIMER1_CAPT_vect)
{
	++Count;

	if (Count == 2)
	{
		PulseWidth = ICR1;
		Count = 0;
		Capture = 1;
	}

	TCNT1 = 0; //Reset Counter
}

By touching tcnt1, you're losing the precision that using the input capture gives you. Since you're running a /64 prescaler, this cuts you a little slack. If the time between the input capture, getting into the isr, executing the code then clearing TCNT1 is less than 64 clocks, then you're home free.

void ICP_Init(void)
{
	//ICP1 enable & CTC
	TIMSK1 |=(1<<ICIE1);	//Enable input capture interrupt
	TCCR1B |=(1<<WGM12);	//CTC Mode. This is used as an overflow.
	TCCR1B |=(1<<ICNC1)|(1<<ICES1)|(1<<CS11)|(1<<CS10); //Noise canceller, rising edge, with 64 prescaler
	TIFR1 |= (1<<ICF1);		//clear interrupt-flag
}


volatile uint16_t PulseWidth;
volatile uint8_t startup_count;
volatile uint8_t Capture;

ISR (TIMER1_COMPA_vect)
{
   startup_count = 2;
   TIMSK1 &=~ (1<<OCIE1A);
   PORTD ^= (1<<PD3);
} 

ISR(TIMER1_CAPT_vect)
{
   static uint16_t prev,curr;

   curr = ICR1;
   PulseWidth =  curr - prev;
   prev = curr;
   if (startup_count)
   {
      startup_count--;
   }
   else
   {
      Capture = 1;
   }
   
   OCR1A = ICR1 + 65535;
   TIMSK1 |= (1<<OCIE1A);
}

int main(void)
{
	DDRD |= (1<<PD3);
	uint16_t pulse;

	USART_Init();
	ICP_Init();
	sei();
	for(;;)
	{
		if (Capture)
		{
			Capture = 0;
			cli();
			pulse = PulseWidth;
			sei();
			USART_SendByte(pulse);
			USART_SendByte(pulse>>8);
		}
	}	
}

It is a pain in the bum using an iPad to write code in a browser