trunk/PIC/lcd.c

/*
 *      LCD interface example
 *      Uses routines from delay.c
 *      This code will interface to a standard LCD controller
 *      like the Hitachi HD44780. It uses it in 4 or 8 bit mode
 *      
 */

#include        <pic18.h>
#include        "lcd.h"
#include        "delay.h"
 

static bit fourbit;             // four or eight bit mode?

#ifdef CHECKBUSY

unsigned char 
lcd_read_cmd_nowait(void)
{
        unsigned char c, readc;

        LCD_DATA_TRIS    = INPUT_DATA;

        LCD_RW = 1; // Read LCD
        asm("nop"); // short propagation delay
        asm("nop"); // short propagation delay

        if (fourbit)
        {
                LCD_STROBE_READ(readc); // Read high nibble
                // Move 4 bits to high nibble while zeroing low nibble
                c = ( ( readc << 4 ) & 0xF0 ); 
                LCD_STROBE_READ(readc); // Read low nibble
                c |= ( readc & 0x0F ); // Or in 4 more bits to low nibble
        }
        else
        {
                LCD_STROBE_READ(readc); 
                c = readc;
        }
        LCD_RW = 0; // Return to default mode of writing LCD
        LCD_DATA_TRIS    = OUTPUT_DATA; // Return to default mode of writing LCD

        return(c);
}

void
lcd_check_busy(void) // Return when the LCD is no longer busy, or we've waiting long enough!
{
        // To avoid hanging forever in event there's a bad or 
        // missing LCD on hardware.  Will just run SLOW, but still run.
        unsigned int retry; 
        unsigned char c;

        for (retry=1000; retry-- > 0; ) {
                c = lcd_read_cmd_nowait();
                if (0==(c&0x80)) break; // Check busy bit.  If zero, no longer busy
        }
}

#endif

/* send a command to the LCD */
void
lcd_cmd(unsigned char c)
{
        LCD_WAIT; // may check LCD busy flag, or just delay a little, depending on lcd.h

        if (fourbit)
        {
                LCD_DATA = ( ( c >> 4 ) & 0x0F );
                LCD_STROBE();
                LCD_DATA = ( c & 0x0F );
                LCD_STROBE();
        }
        else
        {
                LCD_DATA = c;
                LCD_STROBE();
        }
}

/* send data to the LCD */
void
lcd_data(unsigned char c)
{
        LCD_WAIT; // may check LCD busy flag, or just delay a little, depending on lcd.h

        LCD_DATA = 0;
        LCD_RS = 1;
        if (fourbit)
        {
                LCD_DATA |= ( ( c >> 4 ) & 0x0F );      
                LCD_STROBE();
                LCD_DATA &= 0xF0;
                LCD_DATA |= ( c & 0x0F ); 
                LCD_STROBE();
        }
        else
        {
                LCD_DATA = c;
                LCD_STROBE();
        }
        LCD_RS = 0;
}

/* write a string of chars to the LCD */

void
lcd_puts(const char * s)
{
        while(*s)
                lcd_data(*s++);
}

/* initialize the LCD */
void
lcd_init(unsigned char mode)
{
        char init_value;

        fourbit         = 0;
        if (mode == FOURBIT_MODE){
                fourbit = 1;
                init_value = 0x3;
        }else{
                init_value = 0x3F;
        }
        LCD_RS = 0;
        LCD_EN = 0;
        LCD_RW = 0;
        LCD_RS_TRIS      = OUTPUT_PIN;
        LCD_EN_TRIS      = OUTPUT_PIN;
        LCD_RW_TRIS      = OUTPUT_PIN;
        LCD_DATA_TRIS    = OUTPUT_DATA;
        DelayMs(15);
        LCD_DATA         = init_value;
        LCD_STROBE();
        DelayMs(5);
        LCD_DATA         = init_value;
        LCD_STROBE();
        DelayUs(200);
        LCD_DATA         = init_value;
        LCD_STROBE();
        
        if (fourbit){
                LCD_WAIT; //may check LCD busy flag, or just delay a little, depending on lcd.h
                LCD_DATA = 0x2; // Set 4-bit mode
                LCD_STROBE();

                lcd_cmd(0x28); // Function Set
        }else{
                lcd_cmd(0x38);
        }
        lcd_cmd(0xF); //Display On, Cursor On, Cursor Blink
        lcd_cmd(0x1); //Display Clear
        lcd_cmd(0x6); //Entry Mode
        lcd_cmd(0x80); //Initialize DDRAM address to zero
}


1	/*
2	* LCD interface example
3	* Uses routines from delay.c
4	* This code will interface to a standard LCD controller
5	* like the Hitachi HD44780. It uses it in 4 or 8 bit mode
6	*
7	*/
8
9	#include <pic18.h>
10	#include "lcd.h"
11	#include "delay.h"
12
13
14	static bit fourbit; // four or eight bit mode?
15
16	#ifdef CHECKBUSY
17
18	unsigned char
19	lcd_read_cmd_nowait(void)
20	{
21	unsigned char c, readc;
22
23	LCD_DATA_TRIS = INPUT_DATA;
24
25	LCD_RW = 1; // Read LCD
26	asm("nop"); // short propagation delay
27	asm("nop"); // short propagation delay
28
29	if (fourbit)
30	{
31	LCD_STROBE_READ(readc); // Read high nibble
32	// Move 4 bits to high nibble while zeroing low nibble
33	c = ( ( readc << 4 ) & 0xF0 );
34	LCD_STROBE_READ(readc); // Read low nibble
35	c \|= ( readc & 0x0F ); // Or in 4 more bits to low nibble
36	}
37	else
38	{
39	LCD_STROBE_READ(readc);
40	c = readc;
41	}
42	LCD_RW = 0; // Return to default mode of writing LCD
43	LCD_DATA_TRIS = OUTPUT_DATA; // Return to default mode of writing LCD
44
45	return(c);
46	}
47
48	void
49	lcd_check_busy(void) // Return when the LCD is no longer busy, or we've waiting long enough!
50	{
51	// To avoid hanging forever in event there's a bad or
52	// missing LCD on hardware. Will just run SLOW, but still run.
53	unsigned int retry;
54	unsigned char c;
55
56	for (retry=1000; retry-- > 0; ) {
57	c = lcd_read_cmd_nowait();
58	if (0==(c&0x80)) break; // Check busy bit. If zero, no longer busy
59	}
60	}
61
62	#endif
63
64	/* send a command to the LCD */
65	void
66	lcd_cmd(unsigned char c)
67	{
68	LCD_WAIT; // may check LCD busy flag, or just delay a little, depending on lcd.h
69
70	if (fourbit)
71	{
72	LCD_DATA = ( ( c >> 4 ) & 0x0F );
73	LCD_STROBE();
74	LCD_DATA = ( c & 0x0F );
75	LCD_STROBE();
76	}
77	else
78	{
79	LCD_DATA = c;
80	LCD_STROBE();
81	}
82	}
83
84	/* send data to the LCD */
85	void
86	lcd_data(unsigned char c)
87	{
88	LCD_WAIT; // may check LCD busy flag, or just delay a little, depending on lcd.h
89
90	LCD_DATA = 0;
91	LCD_RS = 1;
92	if (fourbit)
93	{
94	LCD_DATA \|= ( ( c >> 4 ) & 0x0F );
95	LCD_STROBE();
96	LCD_DATA &= 0xF0;
97	LCD_DATA \|= ( c & 0x0F );
98	LCD_STROBE();
99	}
100	else
101	{
102	LCD_DATA = c;
103	LCD_STROBE();
104	}
105	LCD_RS = 0;
106	}
107
108	/* write a string of chars to the LCD */
109
110	void
111	lcd_puts(const char * s)
112	{
113	while(*s)
114	lcd_data(*s++);
115	}
116
117	/* initialize the LCD */
118	void
119	lcd_init(unsigned char mode)
120	{
121	char init_value;
122
123	fourbit = 0;
124	if (mode == FOURBIT_MODE){
125	fourbit = 1;
126	init_value = 0x3;
127	}else{
128	init_value = 0x3F;
129	}
130	LCD_RS = 0;
131	LCD_EN = 0;
132	LCD_RW = 0;
133	LCD_RS_TRIS = OUTPUT_PIN;
134	LCD_EN_TRIS = OUTPUT_PIN;
135	LCD_RW_TRIS = OUTPUT_PIN;
136	LCD_DATA_TRIS = OUTPUT_DATA;
137	DelayMs(15);
138	LCD_DATA = init_value;
139	LCD_STROBE();
140	DelayMs(5);
141	LCD_DATA = init_value;
142	LCD_STROBE();
143	DelayUs(200);
144	LCD_DATA = init_value;
145	LCD_STROBE();
146
147	if (fourbit){
148	LCD_WAIT; //may check LCD busy flag, or just delay a little, depending on lcd.h
149	LCD_DATA = 0x2; // Set 4-bit mode
150	LCD_STROBE();
151
152	lcd_cmd(0x28); // Function Set
153	}else{
154	lcd_cmd(0x38);
155	}
156	lcd_cmd(0xF); //Display On, Cursor On, Cursor Blink
157	lcd_cmd(0x1); //Display Clear
158	lcd_cmd(0x6); //Entry Mode
159	lcd_cmd(0x80); //Initialize DDRAM address to zero
160	}
161
162
163