AVR Freaks

Let me not make any assumptions on what os wrong and just give the facts (As I see them)

I have and atmega with a pot giving out a pulse that ranges from approx  1 to 40 hz. I have another atmeg reading the time between cycles every second. 

When at 40 HZ, I get a count of 91516 (my clock's prescaler is 4)

When I start decreasing the frequency, the timer count goes up and then around 2 Hz, the value just keeps increasing each second. It is like both cntH and cntL are never reset.

Every now and then, I get a count much larger that what it should be.

91516	40Hz
91516
91514
163443
146897
155983
117972
215110
215112
215114
215112
116696
170956
170959
170957
170957  20Hz
290749 <------- out of sequence
192329
192331
193355
128721 <--------
180942
180940
180940
180941
333496
426928 <------- out of sequence
426664
426669
189002
264769
579356
609680
692722
775762
858804
1007380  2 hz from now on the count just keeps increasing even though the input is still 2 hz.
1090422
1173464
1256505
1405082
1488122
1571164
1654204
1737245
1820286
1903328
2051905
2134947
2217988
2301029
2449606
2532647
2615689
2698729
2847306
2930347
3013389
3096430
3179471
3262513
3345553
3494131
3577173
3660213
3743255
3891832
3974873
4057914
4140955
4289532
4372573
4455615
4538655

/*
Read input pulse length using PD0
*/

#define F_CPU 16E6
#define USART_BAUDRATE 57600
#define F_BAUD_PRESCALE (((F_CPU/(USART_BAUDRATE*16UL)))-1)  // from manual

#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

#define lcd_SetCursor   0x80    // set cursor position
#define lcd_Clear       0x01

// Functions
void lcd_write_nibble(uint8_t);
void lcd_write_inst(uint8_t);
void lcd_write_char(uint8_t);
void lcd_write_string(uint8_t *);
void lcd_write_long(long);
void lcd_init_4d(void);

void serial_init(unsigned int BAUD_PRESCALE);
void serial_send(char* data);

void init_timer1();
int tov_check(int);

unsigned char sndtime[20];
long cntL;
long cntH;
int edge;			// first occurrence
int i;				// pointer

/******************************* Main Program Code *************************/
int main(void)
{
	lcd_init_4d();        							// initialize the LCD display for a 4-bit interface
	timer1_init();
	serial_init(F_BAUD_PRESCALE);
	while(1)
   {
		edge=1;
		while (!(PIND & (1<<PD0)))      // stay in loop while positive signal
		{
			if (edge == 1)
			{
				TCNT1=0;    // Reset Timer
				cntH=0;
				edge=0;
			}
		 	cntH=tov_check(cntH);     // Count overflows
		}
		while ((PIND & (1<<PD0)))  	 // stay in loop while negative signal
		{
		 	cntH=tov_check(cntH);
		}
		if (!(PIND & (1<<PD0)))      // wait for rising edge
		{
			cntL=TCNT1;           // store timer
			lcd_write_inst(0x01);  // clear display
			lcd_write_inst(0x80);
			_delay_ms(2);
			lcd_write_inst(lcd_SetCursor | 0x00); 	// Line 1
			lcd_write_long(cntH);
			lcd_write_inst(lcd_SetCursor | 0x40); 	// Line 2
			lcd_write_long(cntL);
			cntL=cntL+(cntH<<16);                // Turn into Long
 			ltoa(cntL,sndtime,10);
			serial_send("SS");
			serial_send(sndtime);
			serial_send("EE");
		}
		_delay_ms(1000);
	}
}

void timer1_init()
{
    TCCR1A = 0x00; 								// Normal count Mode and waveform
    TCCR1B = (1 << CS11);						// CS12 and CS10 = 1 Prescaler 4
    TCNT1 = 0;										// Initalize
}

int tov_check(int data)
{
	if (TIFR1 & (1 << TOV1))
	{
		data++;
		TIFR1 = (1 << TOV1);
	}
	return(data);
}

// LCD Setup
void lcd_init_4d(void)
{
	DDRD = 0xF0;			// 4 data lines - output
	DDRB = 0x03;			// Control Lines

	_delay_ms(100);               // initial 40 mSec delay
	lcd_write_nibble(0x30);       // reset sequence
   _delay_ms(10);
	lcd_write_nibble(0x30);
	_delay_us(200);
	lcd_write_nibble(0x30);
	_delay_us(200);  

	lcd_write_inst(0x28);  // Set interface length = 4, Display Lines, Font 5x7
	_delay_us(80);
	lcd_write_inst(0x08);  // turn display OFF
	_delay_us(80);
	lcd_write_inst(0x01);  // clear display RAM
	_delay_ms(4);
	lcd_write_inst(0x06);  // shift cursor from left to right on read/write
	_delay_us(80);
	lcd_write_inst(0x0C);  // turn the display ON
	_delay_us(80);
}                                 

void lcd_write_inst(uint8_t inst)
{
	PORTB &= ~(1<<PORTB0);    		// select the inst Register (RS low)
	lcd_write_nibble(inst);       // write the upper 4-bits of the data
	lcd_write_nibble(inst << 4);  // write the lower 4-bits of the data
	_delay_us(80);
}

void lcd_write_char(uint8_t Data)
{
	PORTB |= (1<<PORTB0);      	// select the Data Register (RS high)
	lcd_write_nibble(Data);       // write the upper 4-bits of the data
	lcd_write_nibble(Data << 4);  // write the lower 4-bits of the data
	_delay_us(80);
}

void lcd_write_nibble(uint8_t theByte)
{
	if (theByte & 1<<7)
		PORTD |= (1<<PORTD7);   //Write 1 which is the actual data
	 else
	 	PORTD &= ~(1<<PORTD7);  //Write 0
	if (theByte & 1<<6)
		PORTD |= (1<<PORTD6);
	 else
	 	PORTD &= ~(1<<PORTD6);
	if (theByte & 1<<5)
		PORTD |= (1<<PORTD5);
	 else
	 	PORTD &= ~(1<<PORTD5);
	if (theByte & 1<<4)
		PORTD |= (1<<PORTD4);
	 else
	 	PORTD &= ~(1<<PORTD4);  

   PORTB &= ~(1<<PORTB1);      // make sure E is initially low
   _delay_us(1);
	PORTB |= (1<<PORTB1);       // Enable pin high
   _delay_us(1);
  	PORTB &= ~(1<<PORTB1);      // Enable pin low
    _delay_us(1);
}

void lcd_write_string(uint8_t String[])
{
	int i = 0;                             // character counter
	while (String[i] != 0)
	{
		lcd_write_char(String[i]);
      i++;
	}
}

void lcd_write_long(long data)
{
	char st[50];
	ltoa(data,st,10);
	lcd_write_string(st);
}

// Serial setup

void serial_init(unsigned int BAUD_PRESCALE)
{
	UBRR0H = (unsigned char)(BAUD_PRESCALE >> 8); 	//Upper 8-bits baud rate, Shift Right 8 times
	UBRR0L = (unsigned char)(BAUD_PRESCALE); 	 		//lower 8-bits.
	UCSR0B = (1 << RXEN0) | (1 << TXEN0); 				// Turn on the transmission and reception circuitry
	UCSR0C = (0 << USBS0) | (3 << UCSZ00); 			// Stop Bits =1  8-bit
}

void serial_send(char *data)   // send a string
{
   while(*data != 0)
   {
		while( !(UCSR0A & (1<<UDRE0))); 						// wait for empty transmit buffer.
		UDR0 = data[i] ;
      data++;
   }
}

After a break, I found the problem. If the input pulse is long, then the code misses the positive edge and goes straight into the negative section which just increases the counter.

Adding this after the 1 sec delay fixed one problem.

		while ((PIND & (1<<PD0)))  	 // stay in loop while negative signal
		{
		 	cntH=tov_check(cntH);
		}

I have another part of the project which will be using an ISR and that timing is critical.

The input is a square wave so the edges are well defined.  However as I rotate the pot, (with a scope on the input, the wave appears to increase nice and linearly ) but I still get these large numbers appearing between valid data. I'm not sure how to look for where they are coming from.

Thanks Wallace