trunk/Embedded/lcd.lst

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