Microchip%20TCP_IP%20stack/TCPIP%20Stack/LCDBlocking.c

/*********************************************************************
 *
 *       LCD Access Routines
 *
 *********************************************************************
 * FileName:        LCDBlocking.c
 * Dependencies:    Compiler.h, HardwareProfile.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.02 or higher
 *                                      Microchip C30 v2.01 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date         Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Howard Schlunder     4/03/06         Original
 * Howard Schlunder     4/12/06         Changed from using PMP to LCDWrite()
 * Howard Schlunder             8/10/06         Fixed a delay being too short 
 *                                                                      when CLOCK_FREQ was a smaller 
 *                                                                      value, added FOUR_BIT_MODE
 ********************************************************************/
#define __LCDBLOCKING_C

#include "TCPIP Stack/TCPIP.h"

#if defined(USE_LCD)


#if defined(PICDEMNET)
#define FOUR_BIT_MODE
#endif

// LCDText is a 32 byte shadow of the LCD text.  Write to it and 
// then call LCDUpdate() to copy the string into the LCD module.
BYTE LCDText[16*2+1];

/******************************************************************************
 * Function:        static void LCDWrite(BYTE RS, BYTE Data)
 *
 * PreCondition:    None
 *
 * Input:           RS - Register Select - 1:RAM, 0:Config registers
 *                                      Data - 8 bits of data to write
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Controls the Port I/O pins to cause an LCD write
 *
 * Note:            None
 *****************************************************************************/
static void LCDWrite(BYTE RS, BYTE Data)
{
        LCD_DATA_TRIS = 0x00;
        LCD_RS_TRIS = 0;
        LCD_RD_WR_TRIS = 0;
        LCD_RD_WR_IO = 0;
        LCD_RS_IO = RS;

#if defined(FOUR_BIT_MODE)
        LCD_DATA_IO = Data>>4;
        Nop();                                  // Wait Data setup time (min 40ns)
        Nop();
        LCD_E_IO = 1;
        Nop();                                  // Wait E Pulse width time (min 230ns)
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        LCD_E_IO = 0;
#endif

        LCD_DATA_IO = Data;
        Nop();                                  // Wait Data setup time (min 40ns)
        Nop();
        LCD_E_IO = 1;
        Nop();                                  // Wait E Pulse width time (min 230ns)
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        Nop();
        LCD_E_IO = 0;

        LCD_DATA_TRIS = 0xFF;
        LCD_RS_TRIS = 1;
        LCD_RD_WR_TRIS = 1;
}


/******************************************************************************
 * Function:        void LCDInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        LCDText[] is blanked, port I/O pin TRIS registers are 
 *                                      configured, and the LCD is placed in the default state
 *
 * Note:            None
 *****************************************************************************/
void LCDInit(void)
{
        BYTE i;

        for(i = 0; i < sizeof(LCDText)-1; i++)
        {
                LCDText[i] = ' ';
        }
        LCDText[sizeof(LCDText)-1] = 0;

        // Setup the I/O pins
        LCD_E_IO = 0;
        LCD_RD_WR_IO = 0;

        LCD_DATA_TRIS = 0x00;
        LCD_RD_WR_TRIS = 0;
        LCD_RS_TRIS = 0;
        LCD_E_TRIS = 0;


        // Wait the required time for the LCD to reset
        DelayMs(30);

        // Set the default function
#if defined(FOUR_BIT_MODE)
        LCDWrite(0, 0x28);
#else
        LCDWrite(0, 0x38);
#endif
        Delay10us(5);

        // Set the display control
        LCDWrite(0, 0x0C);
        Delay10us(5);

        // Clear the display
        LCDWrite(0, 0x01);
        Delay10us(153);
        
        // Set the entry mode
        LCDWrite(0, 0x06);
        Delay10us(5);
}


/******************************************************************************
 * Function:        void LCDUpdate(void)
 *
 * PreCondition:    LCDInit() must have been called once
 *
 * Input:           LCDText[]
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Copies the contents of the local LCDText[] array into the 
 *                                      LCD's internal display buffer.  Null terminators in 
 *                                      LCDText[] terminate the current line, so strings may be 
 *                                      printed directly to LCDText[].
 *
 * Note:            None
 *****************************************************************************/
void LCDUpdate(void)
{
        BYTE i, j;

        // Go home
        LCDWrite(0, 0x02);
        DelayMs(1);
        Delay10us(53);

        // Output first line
        for(i = 0; i < 16u; i++)
        {
                // Erase the rest of the line if a null char is 
                // encountered (good for printing strings directly)
                if(LCDText[i] == 0u)
                {
                        for(j=i; j < 16u; j++)
                        {
                                LCDText[j] = ' ';
                        }
                }
                LCDWrite(1, LCDText[i]);
                Delay10us(5);
        }
        
        // Set the address to the second line
        LCDWrite(0, 0xC0);
        Delay10us(5);

        // Output second line
        for(i = 16; i < 32u; i++)
        {
                // Erase the rest of the line if a null char is 
                // encountered (good for printing strings directly)
                if(LCDText[i] == 0u)
                {
                        for(j=i; j < 32u; j++)
                        {
                                LCDText[j] = ' ';
                        }
                }
                LCDWrite(1, LCDText[i]);
                Delay10us(5);
        }
}

/******************************************************************************
 * Function:        void LCDErase(void)
 *
 * PreCondition:    LCDInit() must have been called once
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Clears LCDText[] and the LCD's internal display buffer
 *
 * Note:            None
 *****************************************************************************/
void LCDErase(void)
{
        // Clear display
        LCDWrite(0, 0x01);
        Delay10us(153);

        // Clear local copy
        memset(LCDText, ' ', 32);
}

#endif  //#if defined(USE_LCD)
1	/*********************************************************************
2	*
3	* LCD Access Routines
4	*
5	*********************************************************************
6	* FileName: LCDBlocking.c
7	* Dependencies: Compiler.h, HardwareProfile.h
8	* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
9	* Complier: Microchip C18 v3.02 or higher
10	* Microchip C30 v2.01 or higher
11	* Company: Microchip Technology, Inc.
12	*
13	* Software License Agreement
14	*
15	* Copyright © 2002-2007 Microchip Technology Inc. All rights
16	* reserved.
17	*
18	* Microchip licenses to you the right to use, modify, copy, and
19	* distribute:
20	* (i) the Software when embedded on a Microchip microcontroller or
21	* digital signal controller product (“Device”) which is
22	* integrated into Licensee’s product; or
23	* (ii) ONLY the Software driver source files ENC28J60.c and
24	* ENC28J60.h ported to a non-Microchip device used in
25	* conjunction with a Microchip ethernet controller for the
26	* sole purpose of interfacing with the ethernet controller.
27	*
28	* You should refer to the license agreement accompanying this
29	* Software for additional information regarding your rights and
30	* obligations.
31	*
32	* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
33	* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
34	* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
35	* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
36	* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
37	* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
38	* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
39	* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
40	* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
41	* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
42	* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
43	*
44	*
45	* Author Date Comment
46	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
47	* Howard Schlunder 4/03/06 Original
48	* Howard Schlunder 4/12/06 Changed from using PMP to LCDWrite()
49	* Howard Schlunder 8/10/06 Fixed a delay being too short
50	* when CLOCK_FREQ was a smaller
51	* value, added FOUR_BIT_MODE
52	********************************************************************/
53	#define __LCDBLOCKING_C
54
55	#include "TCPIP Stack/TCPIP.h"
56
57	#if defined(USE_LCD)
58
59
60	#if defined(PICDEMNET)
61	#define FOUR_BIT_MODE
62	#endif
63
64	// LCDText is a 32 byte shadow of the LCD text. Write to it and
65	// then call LCDUpdate() to copy the string into the LCD module.
66	BYTE LCDText[16*2+1];
67
68	/******************************************************************************
69	* Function: static void LCDWrite(BYTE RS, BYTE Data)
70	*
71	* PreCondition: None
72	*
73	* Input: RS - Register Select - 1:RAM, 0:Config registers
74	* Data - 8 bits of data to write
75	*
76	* Output: None
77	*
78	* Side Effects: None
79	*
80	* Overview: Controls the Port I/O pins to cause an LCD write
81	*
82	* Note: None
83	*****************************************************************************/
84	static void LCDWrite(BYTE RS, BYTE Data)
85	{
86	LCD_DATA_TRIS = 0x00;
87	LCD_RS_TRIS = 0;
88	LCD_RD_WR_TRIS = 0;
89	LCD_RD_WR_IO = 0;
90	LCD_RS_IO = RS;
91
92	#if defined(FOUR_BIT_MODE)
93	LCD_DATA_IO = Data>>4;
94	Nop(); // Wait Data setup time (min 40ns)
95	Nop();
96	LCD_E_IO = 1;
97	Nop(); // Wait E Pulse width time (min 230ns)
98	Nop();
99	Nop();
100	Nop();
101	Nop();
102	Nop();
103	Nop();
104	Nop();
105	Nop();
106	LCD_E_IO = 0;
107	#endif
108
109	LCD_DATA_IO = Data;
110	Nop(); // Wait Data setup time (min 40ns)
111	Nop();
112	LCD_E_IO = 1;
113	Nop(); // Wait E Pulse width time (min 230ns)
114	Nop();
115	Nop();
116	Nop();
117	Nop();
118	Nop();
119	Nop();
120	Nop();
121	Nop();
122	LCD_E_IO = 0;
123
124	LCD_DATA_TRIS = 0xFF;
125	LCD_RS_TRIS = 1;
126	LCD_RD_WR_TRIS = 1;
127	}
128
129
130	/******************************************************************************
131	* Function: void LCDInit(void)
132	*
133	* PreCondition: None
134	*
135	* Input: None
136	*
137	* Output: None
138	*
139	* Side Effects: None
140	*
141	* Overview: LCDText[] is blanked, port I/O pin TRIS registers are
142	* configured, and the LCD is placed in the default state
143	*
144	* Note: None
145	*****************************************************************************/
146	void LCDInit(void)
147	{
148	BYTE i;
149
150	for(i = 0; i < sizeof(LCDText)-1; i++)
151	{
152	LCDText[i] = ' ';
153	}
154	LCDText[sizeof(LCDText)-1] = 0;
155
156	// Setup the I/O pins
157	LCD_E_IO = 0;
158	LCD_RD_WR_IO = 0;
159
160	LCD_DATA_TRIS = 0x00;
161	LCD_RD_WR_TRIS = 0;
162	LCD_RS_TRIS = 0;
163	LCD_E_TRIS = 0;
164
165
166	// Wait the required time for the LCD to reset
167	DelayMs(30);
168
169	// Set the default function
170	#if defined(FOUR_BIT_MODE)
171	LCDWrite(0, 0x28);
172	#else
173	LCDWrite(0, 0x38);
174	#endif
175	Delay10us(5);
176
177	// Set the display control
178	LCDWrite(0, 0x0C);
179	Delay10us(5);
180
181	// Clear the display
182	LCDWrite(0, 0x01);
183	Delay10us(153);
184
185	// Set the entry mode
186	LCDWrite(0, 0x06);
187	Delay10us(5);
188	}
189
190
191	/******************************************************************************
192	* Function: void LCDUpdate(void)
193	*
194	* PreCondition: LCDInit() must have been called once
195	*
196	* Input: LCDText[]
197	*
198	* Output: None
199	*
200	* Side Effects: None
201	*
202	* Overview: Copies the contents of the local LCDText[] array into the
203	* LCD's internal display buffer. Null terminators in
204	* LCDText[] terminate the current line, so strings may be
205	* printed directly to LCDText[].
206	*
207	* Note: None
208	*****************************************************************************/
209	void LCDUpdate(void)
210	{
211	BYTE i, j;
212
213	// Go home
214	LCDWrite(0, 0x02);
215	DelayMs(1);
216	Delay10us(53);
217
218	// Output first line
219	for(i = 0; i < 16u; i++)
220	{
221	// Erase the rest of the line if a null char is
222	// encountered (good for printing strings directly)
223	if(LCDText[i] == 0u)
224	{
225	for(j=i; j < 16u; j++)
226	{
227	LCDText[j] = ' ';
228	}
229	}
230	LCDWrite(1, LCDText[i]);
231	Delay10us(5);
232	}
233
234	// Set the address to the second line
235	LCDWrite(0, 0xC0);
236	Delay10us(5);
237
238	// Output second line
239	for(i = 16; i < 32u; i++)
240	{
241	// Erase the rest of the line if a null char is
242	// encountered (good for printing strings directly)
243	if(LCDText[i] == 0u)
244	{
245	for(j=i; j < 32u; j++)
246	{
247	LCDText[j] = ' ';
248	}
249	}
250	LCDWrite(1, LCDText[i]);
251	Delay10us(5);
252	}
253	}
254
255	/******************************************************************************
256	* Function: void LCDErase(void)
257	*
258	* PreCondition: LCDInit() must have been called once
259	*
260	* Input: None
261	*
262	* Output: None
263	*
264	* Side Effects: None
265	*
266	* Overview: Clears LCDText[] and the LCD's internal display buffer
267	*
268	* Note: None
269	*****************************************************************************/
270	void LCDErase(void)
271	{
272	// Clear display
273	LCDWrite(0, 0x01);
274	Delay10us(153);
275
276	// Clear local copy
277	memset(LCDText, ' ', 32);
278	}
279
280	#endif //#if defined(USE_LCD)