LCD HD44780

1 power ON (internal reset |                | the LCD is initialized. no display
  circuit is trigged       |                |

2 function set             |                | set for 4-bit data. This instruction is
  RS R/W  DB7-DB4          |                | transfered in a single operation since
  0  0  0  0  1  0                            up to this point the LCD unit is in the 8bit mode

3 function set             |                | set for 4-bit data transfer. From this 
  RS R/W  DB7-DB4          |                | point on, data is transferred in two operations
  0  0  0  0  1  0                           
  0  0  1  0  *  *

4 display ON/OFF           |_               | turn on the display and cursor. After
  0  0  0  0  0  0         |                | initialization. the DD RAM is filled
  0  0  1  1  1  0                            with the "space" code


5 entry mode set           |_               | set the LCD unit to increment the address
  0  0  0  0  0  0         |                | counter and shift the cursor to the right
  0  0  0  1  1  0                            after each data transaction
                                              the display does not shift

6 CG RAM/DD RAM            |S_              | write "S" into the DD RAM. The cursor
  data write               |                | shifts to the right
  1  0  0  1  0  1
  1  0  0  0  1  1

      .
      .
      .
 The rest it's just like the 8bit mode

//
//	initialisatie HD44780 controller t.b.v. alphanumeriek LCD Display
//	En gebruiks functies
//
//	Bestand naam: HD44780.C
//	Datum aanvang: 16-04-2004
//	Datum laatst: 16-04-2004
//	Revisie: 0
//
//	Revisiegeschiedenis:
//
//	Rev0: Er kan tekst afgedruk worden.
//
//

//******************************************************************************//
//									     	//
//	Functies:								//
//										//
//		

#include "ks0073.h"
#include <io8515v.h>
#include "iomacro.h"
#define wr_low_nibble(reg, data) data &= 0x0f; reg &= 0xf0; reg |= data

// Display parameters, pindefinities

#define LCD_port_out	PORTA	 	  
#define LCD_port_dir	DDRA
#define LCD_port_in	PINA
#define LCD_E		4
#define LCD_RW		5
#define LCD_RS		6
#define adres_rg1	0x00
#define adres_rg2	0x40
#define adres_rg3	0x14
#define adres_rg4	0x54

// functie set macro's

#define set_lcd_e 		 LCD_port_out |= (1 << LCD_E)
#define clear_lcd_e 	 	 LCD_port_out &= ~(1 << LCD_E)
#define set_lcd_read	 	 LCD_port_out |= (1 << LCD_RW)
#define set_lcd_write		 LCD_port_out &= ~(1 << LCD_RW)
#define set_lcd_data	  	 LCD_port_out |= (1 << LCD_RS)
#define set_lcd_cmd		 LCD_port_out &= ~(1 << LCD_RS)

//LCD commano's

#define display_off	0x08
#define display_on	0x0c
#define cursor_on	0x0e
#define blink_on	0x0d
#define clear_display	0x01

void LCD_delay(unsigned int p)
{
  	unsigned int i;
    	for(i=0;i<p;i++);
}

void write_nibble(unsigned char data)
{
 	clear_lcd_e;		   		// dissable module
 	LCD_port_dir = 0x7f;	   		// bit 0..6 output
 	set_lcd_write;				// zet in schrijf modus
 	data &= 0x0f;				// masker, clear hoog nibble
 	LCD_port_out &=0xf0;   			// wis onderste nibble
 	LCD_port_out |= data;			// schrijf onderste nibble
 	set_lcd_e;				// set E lijn
 	LCD_delay(1);				// houdt E hoog
 	clear_lcd_e;				// clear E lijn
 	LCD_delay(1);				// tweede delay voor eventueel volgende byte
 }
 
void write_byte(unsigned char data)
{
 	unsigned char temp;
 	temp = data;
 	data = data >> 4;
 	write_nibble(data);
 	data = temp;
 	write_nibble(data);
 }
 
 //*****************************************************//
 // This routine will return the busy flag from the LCD //
 //*****************************************************//
 
unsigned char LCD_busy (void)
{
	unsigned char temp;	   		 // opslaan tussenresultaat
	clear_lcd_e;	   			 // Disable module
	LCD_port_dir = 0x70;		 	 // bit 3..0 input
	set_lcd_read;				 // Set LCD to READ
	set_lcd_cmd;				 // Set LCD to command
	set_lcd_e;	   			 // maak e lijn hoog
	LCD_delay(1);				 // ff wachten
	temp = LCD_port_in;			 // Load data from port
	temp = temp << 4;			 // schuif naar hoog nibble
	clear_lcd_e;	   			 // maak e lijn laag
	LCD_delay(1);				 // ff wachten

	// de lage nibble is niet interresant dus die haal ik niet op

	set_lcd_e;				 // maak lijn hoog
	LCD_delay(1);				 // ff wachten
	clear_lcd_e; 				 // maak lijn laag
	set_lcd_data;				 // terug naar data stand
	return temp;				 // return busy flag (bit 7)
}

//*****************************************************//
// This routine will write data to de DDRAM in the LCD //
//*****************************************************//

void LCD_write_ddram(unsigned char data)
{
 	 while (LCD_busy() & 0X80); 		// Test if LCD Busy
	 set_lcd_data;	   	 		// selecteer het "data" register
	 write_byte(data);			// schrijf de data naar de LCD
}	 

//*****************************************************//
// This routine will write data to CMD reg in the LCD  //
//*****************************************************//
	 
void LCD_write_cmd(unsigned char data)	 
{
 	 while (LCD_busy() & 0X80); 		// Test if LCD Busy
	 set_lcd_cmd;	   	 		// selecteer het "command" register
	 write_byte(data);			// schrijf het commando naar de LCD
}

//*****************************************************//
// This routine will write data to the AC of the LCD   //
//*****************************************************//

void LCD_write_ac(unsigned char data)
{
 	 data |= 0x80;			 // set B7
	 LCD_write_cmd(data);		 // schrijf weg als commando
}


void HD44780_ini_4bit(void)
{
 	unsigned char i;
 
	LCD_port_out = 0x00;	  		// maak alle uitgangen laag
	LCD_port_dir = 0x7f;	 		// maar 6--0 als uitgang
   
  	for(i=0; i<10; i++)
  	   LCD_delay(65535);  			// delay ongeveer 40ms

// initialisatie
 		   
	write_nibble(0x03);
	write_nibble(0x03);
	LCD_delay(10000);			// wacht min 4,1ms
	write_nibble(0x03);
	LCD_delay(1000);			// wacht min 100us

	write_nibble(0x02);			// set in 4-bits modus
	LCD_delay(1000);
	write_byte(0x28);			// selecteer 5x8 dots
			  			// 1 regel display
	LCD_delay(1000);			// wacht 70us
	write_byte(0x08);			// display off, no cursor, no blink
	LCD_delay(1000);			// wacht 70us
	write_byte(0x01);  			// clear display en reset DDRAM counter
	LCD_delay(1000);	  		// wacht 70us
	write_byte(0x06); 			//increment DDRAM en no shift
	LCD_delay(1000);
	write_byte(0x0f);			// display aan, cursor aan, blink aan
	LCD_delay(1000);
}	   


// ******************************************************************* //
// *** Display een string op een zekere rij en kolom van de LCD    *** //
// ******************************************************************* //

void LCD_display_string(char rij, char kolom, unsigned char *string)
{
	LCD_cursor(rij, kolom);
	while (*string)
		LCD_write_ddram(*string++);
}

// *************************************************** //
// *** Position the LCD cursor at "rij", "kolom".  *** //
// *************************************************** //

void LCD_cursor(char rij, char kolom)
{
	switch (rij) {
		case 1: LCD_write_ac (adres_rg1 + kolom - 1); break;
		case 2: LCD_write_ac (adres_rg2 + kolom - 1); break;
		case 3: LCD_write_ac (adres_rg3 + kolom - 1); break;
		case 4: LCD_write_ac (adres_rg4 + kolom - 1); break;
		default: break;
	}
}




void main(void)
{
 
 	HD44780_ini_4bit();	   	   		// initialiseer in 4-bits modus
 
 	LCD_write_cmd(display_on);			// zet de display aan
 	LCD_display_string(1,3, "Hoi Sylvester");
 	LCD_display_string(2, 3, "Hij doet het");
 	LCD_display_string(3, 3, "Helemaal in C");
 	LCD_display_string(4, 3, "Nu jij nog :-)");
 
 	while(1);
  
 }
 
			   
		   

//macro's



#define BIT(x) (1 << (x)) 
#define SETBITS(x,y) ((x) |= (y)) 
#define CLEARBITS(x,y) ((x) &= (~(y))) 
#define SETBIT(x,y) SETBITS((x), (BIT((y)))) 
#define CLEARBIT(x,y) CLEARBITS((x), (BIT((y)))) 
#define BITSET(x,y) ((x) & (BIT(y))) 
#define BITCLEAR(x,y) !BITSET((x), (y)) 
#define BITSSET(x,y) (((x) & (y)) == (y)) 
#define BITSCLEAR(x,y) (((x) & (y)) == 0) 
#define BITVAL(x,y) (((x)>>(y)) & 1) 

#define bitget(p,m) ((p) & (m)) 
#define bitset(p,m) ((p) |= (m)) 
#define bitclear(p,m) ((p) &= ~(m)) 
#define bitflip(p,m) ((p) ^= (m)) 
#define bitwrite(c,p,m) (c ? bit_set(p,m) : bit_clear(p,m)) 
//#define BIT(x) (0x01 << (x)) 
#define LONGBIT(x) ((unsigned long)0x00000001 << (x)) 
//To set a bit: 
//bit_set(foo, 0x01); 
//
//To set bit number 5: 
//bit_set(foo, BIT(5)); 
//
//To clear bit number 6 with a bit mask: 
//bit_clear(foo, 0x40); 
//
//To flip bit number 0: 
//bit_flip(foo, BIT(0)); 
//
//To check bit number 3: 
//if(bit_get(foo, BIT(3))) 
//{ 
//} 
//
//To set or clear a bit based on bit number 4: 
//if(bit_get(foo, BIT(4))) 
//{ 
//bit_set(bar, BIT(0)); 
//} 
//else 
//{ 
//bit_clear(bar, BIT(0)); 
//} 
//
//
//To do it with a macro: 
//bit_write(bit_get(foo, BIT(4)), bar, BIT(0)); 
//
//If you are using an unsigned long (32 bit) variable foo, and have to 
//change a bit, use the macro LONGBIT which creates un unsigned long mask.
//Otherwise, using the BIT() macro, the compiler will truncate the value to 16-bits. 

//
//	initialisatie KS0073 controller t.b.v. alphanumeriek LCD Display
//
//	Bestand naam: KS0073.H
//	Datum aanvang: 16-04-2004
//	Datum laatst: 16-04-2004
//	Revisie: 0
//
//	Revisiegeschiedenis:
//
//	Rev0: nog niks werkend
//
//

void LCD_delay(unsigned int p);	// LCD delay routine
void KS0073_ini_4bit(void);		// initialisatie 4-bits modus
void KS0073_ini_8_bit(void);	// initialisatie 8-bits modus
void KS0073_ini_serial(void);	// initialisatie seriele modus
void write_nibble(unsigned char PORT,data); // schrijft een nibble naar de lcd module
void write_byte(unsigned char PORT, data); // schrijft een byte naar de LCD

Alles mag wat mij betreft gewoon gekopieërd en verbeterd worden.