AVR Freaks

// Header files
#include 
#include 
#include 

#include "lcd/lcd.h"
#include "calibration.h"

// Global Variables
volatile long error_corrector;
volatile long glb_ms_counter;
 
// Function Prototypes
void Init_Timer2_CTC(void);
void CheckCurrentLimit(void);
void Read_and_Print_Current(void);

ISR(TIMER2_COMP_vect, ISR_BLOCK)
{
   // Will be called every 1ms.
   
   glb_ms_counter--;
   error_corrector++;

   if((error_corrector == 125) && (glb_msrem_counter >= 3))
   {
      error_corrector = 0;
      glb_ms_counter -= 3;
   }

   if(!(glb_msrem_counter))
   {
      DDRC  |= (1 << 5);
      PORTC &= ~(1 << 5);
      while(1) {};
   }
}


void Init_Timer2_CTC(void)
{   
	ASSR |= (1 << AS2); // External Crystal of 32.768KHz will be used
	TCNT2=0x00;
	OCR2=0x20;
	TCCR2=0x09;   // CTC + 0 presclar
	TIMSK|=0x80;  // CTC interrupt
	SREG |= 0x80; // Enable timer global interrupt
	while (ASSR & ((1 << TCN2UB) | (1 << TCR2UB) | (1 << OCR2UB))); // Wait until crystal stabalised
}


int main(void)
{
	DDRC  |= ((1 << 5) | (1 << 4));
	PORTC |= ((1 << 5) | (1 << 4));
	
	OSCCAL_Calibrate(); 

	glb_msrem_counter = 1400;
	error_corrector   = 0;
   
	lcdInit();
   
	ADMUX  = ((1 << ADLAR) | (1 << REFS1) | (1 << REFS0) | (1 << MUX1) | (1 << MUX0));
	ADCSRA = 0x06;
         
	ADCSRA |= (1 << ADSC);       
	while (ADCSRA & (1 << ADSC)) {};
	
	Init_Timer2_CTC();

	DDRC  |= (1 << 4);
	PORTC &= ~(1 << 4);

	while (1)
	{
		Read_and_Print_Current();
		CheckCurrentLimit();
		_delay_us(200);   
	}

	return 0;
}

void Read_and_Print_Current(void)
{
	float input_current;
	unsigned char val1, val2, val3;
	float a;
   
	// NOTE: This block seems to be a carbon copy of CheckCurrentLimit(void)
	ADCSRA |= (1 << ADSC);    
	while (ADCSRA & (1 << ADSC)) {};       
	a = ADCH;
	input_current = ((a * 2.55) / 255);
	// END NOTE
	
	val1 = (input_current * 1) + 48;
	val2 = (input_current * 10) % 10 + 48;
	val3 = (input_current * 100) %10 + 48;   
   
	lcdGotoXY(0,0);
	lcdDataWrite(val1);
	lcdPrintData(".",1);   
	lcdDataWrite(val2);   
	lcdDataWrite(val3);   
	lcdPrintData(" ",1);
	lcdPrintData("Amp",3);
	lcdPrintData("        ",8);

	_delay_us(500);   
}

void CheckCurrentLimit(void)
{
   float current;
   float input_current;
   float backup_ISet;
   float backup_T;    
   float Idif;
      
   ADCSRA |= (1 << ADSC);       
   while (ADCSRA & (1 << ADSC));                   
   current = ADCH;
   input_current = ((current * 2.55) / 255);
}

////////////////LCD///////////////////////
void lcdGotoXY(unsigned char x, unsigned char y)
{
   unsigned char DDRAMAddr;

   // Re-map lines into proper order
   switch(y)
   {
		case 0:  DDRAMAddr = LCD_LINE0_DDRAMADDR+x; break;
		case 1:  DDRAMAddr = LCD_LINE1_DDRAMADDR+x; break;
		case 2:  DDRAMAddr = LCD_LINE2_DDRAMADDR+x; break;
		case 3:  DDRAMAddr = LCD_LINE3_DDRAMADDR+x; break;
		default: DDRAMAddr = LCD_LINE0_DDRAMADDR+x;
   }

   // Set data address
   lcdControlWrite((1 << LCD_DDRAM) | DDRAMAddr);
}


void lcdDataWrite(unsigned char data)
{
	// Write a data byte to the display
	lcdBusyWait();                         // Wait until LCD not busy
	LCD_CTRL_PORT |= ((1 << LCD_CTRL_RS) | (1 << LCD_CTRL_RW)); // Set RS to "data" and Set R/W to "write"

	// 4 bit write
	LCD_CTRL_PORT |= (1 << LCD_CTRL_E);    // Set "E" line
	LCD_DATA_DDR  |= 0xF0;                 // Set data I/O lines to output (4bit)
	LCD_DATA_POUT  = ((LCD_DATA_POUT & 0x0F) | (data & 0xF0));  // Output data, high 4 bits
	LCD_DELAY;                             // Wait
	LCD_DELAY;                             // Wait
	LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E);   // Clear "E" line
	LCD_DELAY;                             // Wait
	LCD_DELAY;                             // Wait
	LCD_CTRL_PORT |= (1 << LCD_CTRL_E);    // Set "E" line
	LCD_DATA_POUT  = ((LCD_DATA_POUT & 0x0F) | (data << 4));    // Output data, low 4 bits
	LCD_DELAY;                             // Wait
	LCD_DELAY;                             // Wait
	LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E);   // Clear "E" line

	LCD_DATA_DDR  &= 0x0F;                 // Set data I/O lines to input (4bit)
	LCD_DATA_POUT |= 0xF0;                 // set pull-ups to on (4bit)
}

void lcdPrintData(char* data, unsigned char nBytes)
{
	unsigned char i;

	// Check to make sure we have a good pointer
	if (data == NULL) return;

	// Print data
	for(i = 0; i < nBytes; i++)
	  lcdDataWrite(data[i]);
}

void lcdInit()
{
   // Initialize hardware
   lcdInitHW();

   // LCD function set
   lcdControlWrite(LCD_FUNCTION_DEFAULT);

   // clear LCD
   lcdControlWrite(1 << LCD_CLR);
   _delay_ms(60);   // Wait 60ms

   // set entry mode
   lcdControlWrite((1 << LCD_ENTRY_MODE) | (1 << LCD_ENTRY_INC));

   // set display to on
   lcdControlWrite((1 << LCD_ON_CTRL) | (1 << LCD_ON_DISPLAY));

   // move cursor to home
   lcdControlWrite((1 << LCD_HOME));

   // Set data address to 0
   lcdControlWrite((1 << LCD_DDRAM));   
}

void lcdInitHW(void)
{
	// initialize I/O ports
	// if I/O interface is in use

	// initialize LCD control lines
	LCD_CTRL_PORT &= ~((1 << LCD_CTRL_RS) | (1 << LCD_CTRL_RW) | (1 << LCD_CTRL_E));

	// initialize LCD control lines to output
	LCD_CTRL_DDR |= ((1 << LCD_CTRL_RS) | (1 << LCD_CTRL_RW) | (1 << LCD_CTRL_E));

	// initialize LCD data port to input
	// initialize LCD data lines to pull-up
	LCD_DATA_DDR  &= 0x0F;   // Set data I/O lines to input (4bit)
	LCD_DATA_POUT |= 0xF0;   // set pull-ups to on (4bit)
}

void lcdControlWrite(u08 data)
{
	// write the control byte to the display controller
	lcdBusyWait();                       // Wait until LCD not busy
	LCD_CTRL_PORT &= ~((1 << LCD_CTRL_RS) | (1 << LCD_CTRL_RW)); // set RS to "control" and set R/W to "write"

	// 4 bit write
	LCD_CTRL_PORT |= (1 << LCD_CTRL_E);  // Set "E" line
	LCD_DATA_DDR  |= 0xF0;               // Set data I/O lines to output (4bit)
	LCD_DATA_POUT  = ((LCD_DATA_POUT & 0x0F) | (data & 0xF0));   // Output data, high 4 bits
	LCD_DELAY;                           // Wait
	LCD_DELAY;                           // Wait
    LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E); // Clear "E" line
	LCD_DELAY;                           // Wait
	LCD_DELAY;                           // Wait
	LCD_CTRL_PORT |= (1 << LCD_CTRL_E);  // Set "E" line
	LCD_DATA_POUT  = ((LCD_DATA_POUT & 0x0F) | (data << 4));     // Output data, low 4 bits
	LCD_DELAY;                           // Wait
	LCD_DELAY;                           // Wait
	LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E); // Clear "E" line

   //   leave data lines in input mode so they can be most easily used for other purposes
	LCD_DATA_DDR  &= 0x0F);              // Set data I/O lines to input (4bit)
	LCD_DATA_POUT |= 0xF0);              // Set pull-ups to on (4bit)
}

void lcdBusyWait(void)
{
	// wait until LCD busy bit goes to zero
	// do a read from control register
	LCD_CTRL_PORT &= ~(1 << LCD_CTRL_RS);  // set RS to "control"
	LCD_DATA_DDR  &= 0x0F;                 // set data I/O lines to input (4bit)
	LCD_DATA_POUT |= 0xF0;                 // set pull-ups to on (4bit)
	LCD_CTRL_PORT |= ((1 << LCD_CTRL_RW) | (1 << LCD_CTRL_E));  // set R/W to "read" and set "E" line
	LCD_DELAY;                             // Wait
   
	while(LCD_DATA_PIN & (1 << LCD_BUSY))
	{
		LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E);  // clear "E" line
		LCD_DELAY;                            // Wait
		LCD_DELAY;                            // Wait
		LCD_CTRL_PORT |= (1 << LCD_CTRL_E);   // set "E" line
		LCD_DELAY;                            // Wait
		LCD_DELAY;                            // Wait
        LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E);  // clear "E" line
		LCD_DELAY;                            // Wait
		LCD_DELAY;                            // Wait
		LCD_CTRL_PORT |= (1 << LCD_CTRL_E);   // set "E" line
		LCD_DELAY;                            // Wait
	}

	LCD_CTRL_PORT &= ~(1 << LCD_CTRL_E);         // clear "E" line
   //   leave data lines in input mode so they can be most easily used for other purposes
}

...Atmel’s datasheet for the ’8535 advises you to merely connect
the 32,768-Hz watch crystal between the TOSC pins 1 and 2 with no
capacitors to ground. [1]
...
I found that
the crystal oscillator waveform contained serious glitches coinciding with LCD
screen refreshes.
At that point, I was using the port pin adjacent to TOSC1 to drive the LCD
ENABLE pin. Moving the LCD ENABLE pin over to port A eliminated the glitches,
but the clock was still slow.
...
which made me think that capacitance to
ground was probably needed (contrary to the datasheet). It turns out that my
oscilloscope was providing the necessary capacitance, but only when it was
hooked up. Adding 22-pF capacitors to ground cured the problem, at least with
the particular crystal I was using.