初学12864显示汉字和曲线，不知如何入手，求高手指点

Huangwenfeng

初学12864显示汉字和曲线，不知如何入手，求高手指点，单片机是stm32f103ze,急急

macaroni

1. /*******************************************************************************
   
2. * File Name          :
   
3. * Author             :
   
4. * Version            :
   
5. * Date               :
   
6. * Description        :
   
7. ********************************************************************************
   
8. *
   
9. *
   
10. *
    
11. *
    
12. *
    
13. *
    
14. *******************************************************************************/
    
15. 
    
16. /* Includes ------------------------------------------------------------------*/
    
17. #include "LCD.h"
    
18. 
    
19. /* Private typedef -----------------------------------------------------------*/
    
20. typedef void (*pFunctionr)(void);
    
21. typedef uint8_t (*pFunctionw)(void);
    
22. /* Private define ------------------------------------------------------------*/
    
23. /* Private macro -------------------------------------------------------------*/
    
24. #define SET_WR                                                         GPIO_SetBits(GPIOC,WR)
    
25. #define RESET_WR                                                 GPIO_ResetBits(GPIOC,WR)
    
26. 
    
27. #define SET_CE                                                         GPIO_SetBits(GPIOC,CE)
    
28. #define RESET_CE                                                 GPIO_ResetBits(GPIOC,CE)
    
29. 
    
30. #define SET_RD                                                         GPIO_SetBits(GPIOC,RD)
    
31. #define RESET_RD                                                 GPIO_ResetBits(GPIOC,RD)
    
32. 
    
33. #define SET_CD                                                         GPIO_SetBits(GPIOA,CD)
    
34. #define RESET_CD                                                 GPIO_ResetBits(GPIOA,CD)
    
35. 
    
36. #define SET_RST                                                 GPIO_SetBits(GPIOA,RST)
    
37. #define RESET_RST                                                 GPIO_ResetBits(GPIOA,RST)
    
38. 
    
39. #define SET_D0                                                         GPIO_SetBits(GPIOC,D0)
    
40. #define RESET_D0                                                 GPIO_ResetBits(GPIOC,D0)
    
41. 
    
42. #define SET_D1                                                         GPIO_SetBits(GPIOC,D1)
    
43. #define RESET_D1                                                 GPIO_ResetBits(GPIOC,D1)
    
44. 
    
45. #define SET_D2                                                         GPIO_SetBits(GPIOC,D2)
    
46. #define RESET_D2                                                 GPIO_ResetBits(GPIOC,D2)
    
47. 
    
48. #define SET_D3                                                         GPIO_SetBits(GPIOB,D3)
    
49. #define RESET_D3                                                 GPIO_ResetBits(GPIOB,D3)
    
50. 
    
51. #define SET_D4                                                         GPIO_SetBits(GPIOB,D4)
    
52. #define RESET_D4                                                 GPIO_ResetBits(GPIOB,D4)
    
53. 
    
54. #define SET_D5                                                         GPIO_SetBits(GPIOB,D5)
    
55. #define RESET_D5                                                 GPIO_ResetBits(GPIOB,D5)
    
56. 
    
57. #define SET_D6                                                         GPIO_SetBits(GPIOB,D6)
    
58. #define RESET_D6                                                 GPIO_ResetBits(GPIOB,D6)
    
59. 
    
60. #define SET_D7                                                         GPIO_SetBits(GPIOB,D7)
    
61. #define RESET_D7                                                 GPIO_ResetBits(GPIOB,D7)
    
62. 
    
63. 
    
64. #define VERTICAL_LENGTH                                         128
    
65. #define VERTICAL_MODULE                                 16
    
66. 
    
67. #define HORIZONTAL_LENGTH                                240
    
68. #define HORIZONTAL_MODULE                                30
    
69. 
    
70. #define TextDisRamSize                                        HORIZONTAL_MODULE * VERTICAL_MODULE
    
71. #define GrapDisRamSize                                        HORIZONTAL_MODULE * VERTICAL_LENGTH
    
72. #define TextRamOffset                                        0
    
73. #define GrapRamOffset                                        HORIZONTAL_MODULE * VERTICAL_LENGTH
    
74. 
    
75. 
    
76. #define __Cursor                                                        0x01
    
77. #define __CGRAM                                                0x02
    
78. #define __DisBuf                                                        0x04
    
79. #define CMDSetAddrPointer                                        0x20
    
80. 
    
81. #define CMDSetTextRamOffset                                0x40
    
82. #define CMDSetTextRamProperty                                0X41
    
83. #define CMDSetGrapRamOffset                                0x42
    
84. #define CMDSetGrapRamProperty                                0X43
    
85. 
    
86. #define __OR                                                        0x00
    
87. #define __XOR                                                        0x01
    
88. #define __AND                                                        0x03
    
89. #define __Double                                                0x04
    
90. #define CMDSynthetizeRamModel                                0x80
    
91. 
    
92. #define __EnableCursorFlash                                        0x01
    
93. #define __EnableCursor                                        0x02
    
94. #define __EnableTextDisplay                                        0x04
    
95. #define __EnableGrapDisplay                                        0x08
    
96. 
    
97. #define CMDSetDisplayShape                                0x90
    
98. 
    
99. #define __OneLine                                                0x00
    
100. #define __TwoLine                                                0x01
     
101. #define __ThreeLine                                                0x02
     
102. #define __FourLine                                                0x03
     
103. #define __Fiveine                                                0x04
     
104. #define __SixLine                                                0x05
     
105. #define __SevenLine                                                0x06
     
106. #define __EightLine                                                0x07
     
107. #define CMDSetCursorModel                                        0xA0
     
108. 
     
109. 
     
110. #define __Write                                                        0x00
     
111. #define __Read                                                        0x01
     
112. #define __Esc                                                        0x02
     
113. #define CMDSetAutoDataTrans                                0xB0
     
114. 
     
115. #define __WritePlus                                                0x00
     
116. #define __ReadPlus                                                0x01
     
117. #define __WriteSubtract                                        0x02
     
118. #define __ReadSubtract                                        0x03
     
119. #define __WriteNoOffset                                        0x04
     
120. #define __ ReadNoOffset                                        0x05
     
121. #define CMDSetOneTimesDataTrans                        0xC0
     
122. 
     
123. #define CMDReadOneByteDisRam                                0xE0
     
124. #define CMDReadOneLineDisRam                                0xE8
     
125. #define CMDBitWrite                                                0xF0
     
126. 
     
127. #define OneByteTransRdy                                        0x03
     
128. #define AutoWriteTransRdy                                        0x08
     
129. #define AutoReadTransRdy                                        0x04
     
130. /* Private variables ---------------------------------------------------------*/
     
131. const uint8_t SetTextRamOffset[]                 = {TextRamOffset     % 256,TextRamOffset          >> 8,CMDSetTextRamOffset};
     
132. const uint8_t SetTextRamProperty[]                 = {HORIZONTAL_MODULE % 256,HORIZONTAL_MODULE >> 8,CMDSetTextRamProperty};
     
133. const uint8_t SetGrapRamOffset[]                 = {GrapRamOffset         % 256,GrapRamOffset     >> 8,CMDSetGrapRamOffset};
     
134. const uint8_t SetGrapRamProperty[]                 = {HORIZONTAL_MODULE % 256,HORIZONTAL_MODULE >> 8,CMDSetGrapRamProperty};
     
135. const uint8_t SetSynthetizeRamModel                 = CMDSynthetizeRamModel | __OR;
     
136. const uint8_t SetDisplayShape                         = CMDSetDisplayShape         | //__EnableCursorFlash | __EnableCursor |
     
137.                                                                                                                                   __EnableTextDisplay | __EnableGrapDisplay;
     
138. 
     
139. const uint8_t SetCursorSetting                           = CMDSetCursorModel | __TwoLine;
     
140. 
     
141. const uint8_t SetAutoTransRead                        = CMDSetAutoDataTrans | __Read;
     
142. const uint8_t SetAutoTransWrite                        = CMDSetAutoDataTrans | __Write;
     
143. const uint8_t SetAutoTransEsc                        = CMDSetAutoDataTrans | __Esc;
     
144. 
     
145. uint8_t SetAddrPointer[]                                = {0X00,0X00,CMDSetAddrPointer | __DisBuf};
     
146. uint8_t SetCursorPointer[]                                = {0X00,0X00,CMDSetAddrPointer | __Cursor};
     
147. uint8_t SetOneTimesDataTrans[]                        = {0x00,CMDSetOneTimesDataTrans |__WritePlus};
     
148. 
     
149. uint8_t TextDisBuf [HORIZONTAL_MODULE * VERTICAL_MODULE] = {0};
     
150. uint8_t GrapDisBuf [HORIZONTAL_MODULE * VERTICAL_LENGTH] = {0};         //
     
151. /* Private function prototypes -----------------------------------------------*/
     
152. void SetD0(void)
     
153. {GPIO_WriteBit(GPIOC,D0,Bit_SET);}
     
154. 
     
155. void ResetD0(void)
     
156. {GPIO_WriteBit(GPIOC,D0,Bit_RESET);}
     
157. 
     
158. void SetD1(void)
     
159. {GPIO_WriteBit(GPIOC,D1,Bit_SET);}
     
160. 
     
161. void ResetD1(void)
     
162. {GPIO_WriteBit(GPIOC,D1,Bit_RESET);}
     
163. 
     
164. void SetD2(void)
     
165. {GPIO_WriteBit(GPIOB,D2,Bit_SET);}
     
166. 
     
167. void ResetD2(void)
     
168. {GPIO_WriteBit(GPIOB,D2,Bit_RESET);}
     
169. 
     
170. void SetD3(void)
     
171. {GPIO_WriteBit(GPIOB,D3,Bit_SET);}
     
172. 
     
173. void ResetD3(void)
     
174. {GPIO_WriteBit(GPIOB,D3,Bit_RESET);}
     
175. 
     
176. void SetD4(void)
     
177. {GPIO_WriteBit(GPIOB,D4,Bit_SET);}
     
178. 
     
179. void ResetD4(void)
     
180. {GPIO_WriteBit(GPIOB,D4,Bit_RESET);}
     
181. 
     
182. void SetD5(void)
     
183. {GPIO_WriteBit(GPIOB,D5,Bit_SET);}
     
184. 
     
185. void ResetD5(void)
     
186. {GPIO_WriteBit(GPIOB,D5,Bit_RESET);}
     
187. 
     
188. void SetD6(void)
     
189. {GPIO_WriteBit(GPIOB,D6,Bit_SET);}
     
190. 
     
191. void ResetD6(void)
     
192. {GPIO_WriteBit(GPIOB,D6,Bit_RESET);}
     
193. 
     
194. void SetD7(void)
     
195. {GPIO_WriteBit(GPIOB,D7,Bit_SET);}
     
196. 
     
197. void ResetD7(void)
     
198. {GPIO_WriteBit(GPIOB,D7,Bit_RESET);}
     
199. 
     
200. uint8_t ReadD0(void)          {return (GPIO_ReadInputDataBit(GPIOC,D0) << 0);}
     
201. uint8_t ReadD1(void)        {return (GPIO_ReadInputDataBit(GPIOC,D1) << 1);}
     
202. uint8_t ReadD2(void)        {return (GPIO_ReadInputDataBit(GPIOB,D2) << 2);}
     
203. uint8_t ReadD3(void)        {return (GPIO_ReadInputDataBit(GPIOB,D3) << 3);}
     
204. uint8_t ReadD4(void)        {return (GPIO_ReadInputDataBit(GPIOB,D4) << 4);}
     
205. uint8_t ReadD5(void)        {return (GPIO_ReadInputDataBit(GPIOB,D5) << 5);}
     
206. uint8_t ReadD6(void)        {return (GPIO_ReadInputDataBit(GPIOB,D6) << 6);}
     
207. uint8_t ReadD7(void)        {return (GPIO_ReadInputDataBit(GPIOB,D7) << 7);}
     
208. 
     
209. const pFunctionr wpl[8] = {ResetD0,ResetD1,ResetD2,ResetD3,ResetD4,ResetD5,ResetD6,ResetD7};
     
210. const pFunctionr wph[8] = {SetD0,SetD1,SetD2,SetD3,SetD4,SetD5,SetD6,SetD7};
     
211. pFunctionr                  wp[8]         = {ResetD0,ResetD1,ResetD2,ResetD3,ResetD4,ResetD5,ResetD6,ResetD7};
     
212. const pFunctionw rp[8]  = {ReadD0,ReadD1,ReadD2,ReadD3,ReadD4,ReadD5,ReadD6,ReadD7};
     
213. /* Private functions ---------------------------------------------------------*/
     
214. uint8_t ReadDataBus(void)
     
215. {
     
216.         uint8_t data = 0;
     
217.         uint8_t index = 0;
     
218.         GPIO_InitTypeDef  GPIO_InitStructure;
     
219.        
     
220.         GPIO_InitStructure.GPIO_Pin = D0 | D1;
     
221.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
     
222.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
     
223.         GPIO_Init(GPIOC,&GPIO_InitStructure);
     
224.        
     
225.         GPIO_InitStructure.GPIO_Pin = D2 | D3 | D4 | D5| D6 | D7;
     
226.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
     
227.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
     
228.         GPIO_Init(GPIOB,&GPIO_InitStructure);
     
229.         for (index = 0; index < 8;index++)
     
230.         {
     
231.                 data |= rp[index]();
     
232.         }
     
233.         return data;
     
234. }
     
235. void WriteDataBus(uint8_t data)
     
236. {
     
237.         uint8_t index = 0;
     
238.         GPIO_InitTypeDef  GPIO_InitStructure;
     
239.        
     
240.         GPIO_InitStructure.GPIO_Pin = D0 | D1;
     
241.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
     
242.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
243.         GPIO_Init(GPIOC,&GPIO_InitStructure);
     
244.        
     
245.         GPIO_InitStructure.GPIO_Pin = D2 | D3 | D4 | D5| D6 | D7;
     
246.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
     
247.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
248.         GPIO_Init(GPIOB,&GPIO_InitStructure);
     
249.         for(index = 0;index < 8;index++)
     
250.         {
     
251.                 wp[index] = (0x01 << index) & data ? wph[index] : wpl[index];
     
252.         }
     
253.         for(index = 0;index < 8;index++)
     
254.         {
     
255.                 wp[index]();
     
256.         }
     
257. }
     
258. uint8_t GetStatusBit()
     
259. {
     
260.         uint8_t temp = 0;
     
261.        
     
262.         SET_CD;       
     
263.         RESET_RD;
     
264.         SET_WR;
     
265.         RESET_CE;       
     
266.         temp = ReadDataBus();
     
267.         SET_CE;               
     
268.         SET_CD;
     
269.         SET_RD;
     
270.         SET_WR;
     
271.         return temp;
     
272. }
     
273. void WriteData(uint8_t data)
     
274. {
     
275.         while((GetStatusBit() & OneByteTransRdy) != OneByteTransRdy);
     
276.         WriteDataBus(data);
     
277.         RESET_CD;
     
278.         SET_RD;
     
279.         RESET_WR;
     
280.         RESET_CE;       
     
281.         RESET_CE;               
     
282.         SET_CE;       
     
283.         SET_CD;
     
284.         SET_RD;
     
285.         SET_WR;
     
286.         while((GetStatusBit() & OneByteTransRdy) != OneByteTransRdy);
     
287. }
     
288. 
     
289. void WriteCMD(uint8_t data)
     
290. {
     
291.        
     
292.         while((GetStatusBit() & OneByteTransRdy) != OneByteTransRdy);
     
293.         WriteDataBus(data);       
     
294.         SET_CD;       
     
295.         SET_RD;
     
296.         RESET_WR;       
     
297.         RESET_CE;               
     
298.         RESET_CE;       
     
299.         SET_CE;       
     
300.         SET_CD;
     
301.         SET_RD;
     
302.         SET_WR;
     
303.         while((GetStatusBit() & OneByteTransRdy) != OneByteTransRdy);
     
304. }
     
305. void AutoReadData(uint8_t *p,uint16_t len)
     
306. {
     
307.         uint8_t temp = 0;
     
308.         WriteCMD(SetAutoTransRead);
     
309.         while(len-- != 0)
     
310.         {
     
311.                 while((GetStatusBit() & AutoReadTransRdy) != AutoReadTransRdy);
     
312.                 RESET_CD;
     
313.                 SET_WR;
     
314.                 RESET_RD;               
     
315.                 RESET_CE;
     
316.                 temp = ReadDataBus();
     
317.                 *p++ = temp;;
     
318.                 SET_CE;       
     
319.                 SET_CD;
     
320.                 SET_RD;
     
321.                 SET_WR;               
     
322.         }
     
323.         while((GetStatusBit() & AutoReadTransRdy) != AutoReadTransRdy);       
     
324.         WriteCMD(SetAutoTransEsc);
     
325. }
     
326. void AutoWriteData(uint8_t *p,uint16_t len)
     
327. {
     
328.         WriteCMD(SetAutoTransWrite);
     
329.         while(len-- != 0)
     
330.         {
     
331.                 while((GetStatusBit() & AutoWriteTransRdy) != AutoWriteTransRdy);       
     
332.                 WriteDataBus(*p++);               
     
333.                 RESET_CD;
     
334.                 SET_RD;
     
335.                 RESET_WR;
     
336.                 RESET_CE;       
     
337.                 RESET_CE;               
     
338.                 SET_CE;       
     
339.                 SET_CD;
     
340.                 SET_RD;
     
341.                 SET_WR;
     
342.         }
     
343.         while((GetStatusBit() & AutoWriteTransRdy) != AutoWriteTransRdy);
     
344.         WriteCMD(SetAutoTransEsc);
     
345. }
     
346. void WriteOneByte(uint8_t data)
     
347. {
     
348.                
     
349. }
     
350. void LCDZeroInit(void)
     
351. {
     
352.         uint16_t index = 0;
     
353.         /* clr text buffer */
     
354.         SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
355.         SetAddrPointer[1] = TextRamOffset >> 8;
     
356.         SetAddrPointer[0] = TextRamOffset % 256;
     
357.         WriteData(SetAddrPointer[0]);
     
358.         WriteData(SetAddrPointer[1]);
     
359.         WriteCMD(SetAddrPointer[2]);       
     
360.         for (index = 0;index < TextDisRamSize;index++)
     
361.                 TextDisBuf[index] = 0x00;
     
362.         AutoWriteData(TextDisBuf,TextDisRamSize);
     
363.         #ifdef LCD_USER_DEBUG
     
364.                 /* set text buffer */
     
365.                 SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
366.                 SetAddrPointer[1] = TextRamOffset >> 8;
     
367.                 SetAddrPointer[0] = TextRamOffset % 256;
     
368.                 WriteData(SetAddrPointer[0]);
     
369.                 WriteData(SetAddrPointer[1]);
     
370.                 WriteCMD(SetAddrPointer[2]);       
     
371.                 for (index = 0;index < TextDisRamSize;index++)
     
372.                         TextDisBuf[index] = 0x01;
     
373.                 AutoWriteData(TextDisBuf,TextDisRamSize);
     
374.                 /* read text buffer */
     
375.                 SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
376.                 SetAddrPointer[1] = TextRamOffset >> 8;
     
377.                 SetAddrPointer[0] = TextRamOffset % 256;
     
378.                 WriteData(SetAddrPointer[0]);
     
379.                 WriteData(SetAddrPointer[1]);
     
380.                 WriteCMD(SetAddrPointer[2]);
     
381.                 for (index = 0;index < TextDisRamSize;index++)
     
382.                         TextDisBuf[index] = 0x00;
     
383.                 AutoReadData(TextDisBuf,TextDisRamSize);
     
384.                 for (index = 0;index < TextDisRamSize;index++)
     
385.                         if (TextDisBuf[index] != 0x01)
     
386.                                 while(1);
     
387.         #endif               
     
388.         /* clr grap buffer */
     
389.         SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
390.         SetAddrPointer[1] = GrapRamOffset >> 8;
     
391.         SetAddrPointer[0] = GrapRamOffset % 256;
     
392.         WriteData(SetAddrPointer[0]);
     
393.         WriteData(SetAddrPointer[1]);
     
394.         WriteCMD(SetAddrPointer[2]);       
     
395.         for (index = 0;index < GrapDisRamSize;index++)
     
396.                 GrapDisBuf[index] = 0x00;
     
397.         AutoWriteData(GrapDisBuf,GrapDisRamSize);
     
398.         #ifdef LCD_USER_DEBUG
     
399.                 /* set grap buffer */       
     
400.                 SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
401.                 SetAddrPointer[1] = GrapRamOffset >> 8;
     
402.                 SetAddrPointer[0] = GrapRamOffset % 256;
     
403.                 WriteData(SetAddrPointer[0]);
     
404.                 WriteData(SetAddrPointer[1]);
     
405.                 WriteCMD(SetAddrPointer[2]);       
     
406.                 for (index = 0;index < GrapDisRamSize;index++)
     
407.                         GrapDisBuf[index] = 0x81;
     
408.                 AutoWriteData(GrapDisBuf,GrapDisRamSize);               
     
409.                        
     
410.                 SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
411.                 SetAddrPointer[1] = GrapRamOffset >> 8;
     
412.                 SetAddrPointer[0] = GrapRamOffset % 256;
     
413.                 WriteData(SetAddrPointer[0]);
     
414.                 WriteData(SetAddrPointer[1]);
     
415.                 WriteCMD(SetAddrPointer[2]);
     
416.                 for (index = 0;index < GrapDisRamSize;index++)
     
417.                         GrapDisBuf[index] = 0x00;               
     
418.                 AutoReadData(GrapDisBuf,GrapDisRamSize);
     
419.                 for (index = 0;index < GrapDisRamSize;index++)
     
420.                         if (GrapDisBuf[index] != 0x81)
     
421.                                 while(1);
     
422.         #endif
     
423. }
     
424. void LCDInit(void)
     
425. {
     
426.         uint32_t index = 0;
     
427.         for (index = 0;index < 500000;index++)
     
428.                 RESET_RST;
     
429.         for (index = 0;index < 500000;index++)
     
430.                 SET_RST;
     
431.         WriteData(SetTextRamOffset[0]);
     
432.         WriteData(SetTextRamOffset[1]);
     
433.         WriteCMD(SetTextRamOffset[2]);
     
434.        
     
435.         WriteData(SetTextRamProperty[0]);
     
436.         WriteData(SetTextRamProperty[1]);
     
437.         WriteCMD(SetTextRamProperty[2]);
     
438.        
     
439.         WriteData(SetGrapRamOffset[0]);
     
440.         WriteData(SetGrapRamOffset[1]);
     
441.         WriteCMD(SetGrapRamOffset[2]);
     
442. 
     
443.         WriteData(SetGrapRamProperty[0]);
     
444.         WriteData(SetGrapRamProperty[1]);
     
445.         WriteCMD(SetGrapRamProperty[2]);
     
446.        
     
447.        
     
448.         WriteCMD(SetSynthetizeRamModel);
     
449.         WriteCMD(SetDisplayShape);       
     
450.         WriteCMD(SetCursorSetting);
     
451.        
     
452. //         SetCursorPointer[2] = CMDSetAddrPointer | __Cursor;
     
453. //         SetCursorPointer[1] = 0x00;//GrapRamOffset >> 8;
     
454. //         SetCursorPointer[0] = 0x00;//GrapRamOffset % 256;
     
455. //         WriteData(SetCursorPointer[0]);
     
456. //         WriteData(SetCursorPointer[1]);
     
457. //         WriteCMD(SetCursorPointer[2]);
     
458.                
     
459.         LCDZeroInit();
     
460. }
     
461. void ReadGrapRam(LCDData *data)
     
462. {
     
463.         uint8_t col_index = 0;
     
464.         uint8_t row_index = 0;
     
465.         uint16_t index    = 0;
     
466.        
     
467.         uint8_t src_bit = 0;
     
468.         uint8_t src_byte = 0;
     
469.        
     
470.         uint8_t des_bit = 0;
     
471.                  
     
472.         for (row_index = 0;row_index < data->heigth;row_index++)       
     
473.         {
     
474.                 for (col_index = 0;col_index < data->width;col_index++)
     
475.                 {
     
476.                         index = (data->x_pixel + col_index) / 8 + (row_index + data->y_pixel) * HORIZONTAL_MODULE;
     
477.                
     
478.                         src_byte = *(GrapDisBuf + index );
     
479.                        
     
480.                         src_bit  = (src_byte & (0x80 >> ((data->x_pixel + col_index) % 8)))? 0x80 : 0x00;
     
481.                        
     
482.                         des_bit  = src_bit >> (col_index % 8);
     
483.        
     
484.                         *(data->data + (col_index + row_index * data->width) / 8) |= (uint8_t)des_bit;               
     
485.                 }
     
486.         }
     
487. }
     
488. void WriteGrapRam(LCDData *data)
     
489. {
     
490.         uint8_t col_index = 0;
     
491.         uint8_t row_index = 0;
     
492.         uint16_t index    = 0;
     
493.        
     
494.         uint8_t src_bit = 0;
     
495.         uint8_t src_byte = 0;
     
496.        
     
497.         uint8_t des_bit = 0;
     
498. 
     
499.         for (row_index = 0;row_index < data->heigth;row_index++)       
     
500.         {
     
501.                 for (col_index = 0;col_index < data->width;col_index++)
     
502.                 {
     
503.                         index = (data->x_pixel + col_index) / 8 + (row_index + data->y_pixel) * HORIZONTAL_MODULE;
     
504.                
     
505.                         src_byte = *(data->data + (col_index + row_index * data->width) / 8 );
     
506.                         src_bit  = (src_byte & (0x80 >> ((col_index + row_index * data->width) % 8))) ? 0x80 : 0x00;
     
507.                        
     
508.                         des_bit  = src_bit >> (data->x_pixel + col_index) % 8;
     
509.        
     
510.                         GrapDisBuf[index] |= (uint8_t)des_bit;       
     
511.                
     
512.                 }
     
513.         }
     
514.        
     
515. }
     
516. void ClrGrapRam(LCDData *data)
     
517. {
     
518.         uint8_t col_index = 0;
     
519.         uint8_t row_index = 0;
     
520.         uint16_t index    = 0;
     
521.         /* clr grap ram */
     
522.         for (row_index = 0;row_index < data->heigth;row_index++)       
     
523.         {
     
524.                 index = (row_index + data->y_pixel) * HORIZONTAL_MODULE;
     
525.                 GrapDisBuf[index + data->x_pixel / 8] &= (~(0xFF >> (data->x_pixel % 8)));
     
526.                 GrapDisBuf[index + (data->x_pixel + data->width) / 8] &=  (0xFF >> (data->x_pixel + data->width) % 8);
     
527.                 for (col_index = data->x_pixel / 8 + 1;col_index < (data->x_pixel + data->width) / 8;col_index++)
     
528.                 {                                       
     
529.                         GrapDisBuf[index + col_index] = 0;               
     
530.                 }
     
531.         }
     
532. }
     
533. 
     
534. void CopyClrGrapRam(LCDData *srcdata,LCDData* dstdata)
     
535. {
     
536.        
     
537.        
     
538. }
     
539. void RefurbishLCD(LCDData *data)
     
540. {
     
541.         uint8_t index = 0;
     
542.         uint8_t length = 0;
     
543.         uint32_t ramoffset = 0;
     
544.         uint32_t bufoffset = 0;
     
545. 
     
546.         for (index = 0;index < data->heigth;index++)
     
547.         {
     
548.                 if ((data->x_pixel) % 8 == 0 && (data->width) % 8 == 0)
     
549.                 {
     
550.                         bufoffset = data->x_pixel / 8 + (data->y_pixel + index) * HORIZONTAL_MODULE;
     
551.                         ramoffset = GrapRamOffset + bufoffset;
     
552.                         length = data->width / 8;
     
553.                         SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
554.                         SetAddrPointer[1] = ramoffset >> 8;
     
555.                         SetAddrPointer[0] = ramoffset % 256;
     
556.                         WriteData(SetAddrPointer[0]);
     
557.                         WriteData(SetAddrPointer[1]);
     
558.                         WriteCMD(SetAddrPointer[2]);       
     
559.                         AutoWriteData(GrapDisBuf + bufoffset,length);
     
560. 
     
561.                 }
     
562.                 else
     
563.                 {                       
     
564.                         bufoffset = ((data->x_pixel - (data->x_pixel % 8)) / 8) + (data->y_pixel + index) * HORIZONTAL_MODULE;
     
565.                         ramoffset = GrapRamOffset + bufoffset;
     
566.                         length = ((data->x_pixel + data->width) - ((data->x_pixel + data->width) % 8) + 8) / 8 - (data->x_pixel - (data->x_pixel % 8)) / 8;
     
567.                         SetAddrPointer[2] = CMDSetAddrPointer | __DisBuf;
     
568.                         SetAddrPointer[1] = ramoffset >> 8;
     
569.                         SetAddrPointer[0] = ramoffset % 256;
     
570.                         WriteData(SetAddrPointer[0]);
     
571.                         WriteData(SetAddrPointer[1]);
     
572.                         WriteCMD(SetAddrPointer[2]);       
     
573.                         AutoWriteData(GrapDisBuf + bufoffset,length);               
     
574.                 }
     
575.         }
     
576. }
     
577. #ifdef USER_DEBUG
     
578. void CheckGrapRam(void)
     
579. {
     
580.         LCDData __data;
     
581.         __data.x_pixel = 0;
     
582.         __data.y_pixel        = 0;
     
583.         __data.width   = 240;
     
584.         __data.heigth  = 128;
     
585.         RefurbishLCD(&__data);
     
586. }
     
587. #endif
     

复制代码

macaroni

1. typedef __packed struct LCDDataTag
   
2. {
   
3.         /* 页面关系 */
   
4.         uint16_t net;
   
5.         /* 数据区 */
   
6.         uint8_t x_pixel;
   
7.         uint8_t y_pixel;
   
8.         uint8_t width;
   
9.         uint8_t heigth;
   
10.         uint8_t* data;
    
11. }LCDData;

复制代码

macaroni

这是240 128 的 凑合着看吧···

Huangwenfeng

macaroni 发表于 2013-8-27 14:04
这是240 128 的 凑合着看吧···

谢谢，非常感谢

qinshiysb

/********************************************************/
/********************************************************/
/****12864驱动程序头文件********************/
/********************************************************/
/********************************************************/
#ifndef __LCD_12864_H
#define __LCD_12864_H
/********************************************************/
/********************************************************/
#include "stm32f10x.h"
/********************************************************/
/********************************************************/
#define UP   1
#define DOWN 0
/********************************************************/
/********************************************************/
/*液晶数据端口定义  PD口*/
//#define LCD_DATA GPIOD
/********************************************************/
/********************************************************/
/*液晶端口定义*/
#define LCD_CS(a)        if (a) \
                                        GPIO_SetBits(GPIOB,GPIO_Pin_10);\
                                        else                \
                                        GPIO_ResetBits(GPIOB,GPIO_Pin_10)

#define LCD_SID(a)        if (a)        \
                                        GPIO_SetBits(GPIOB,GPIO_Pin_11);\
                                        else                \
                                        GPIO_ResetBits(GPIOB,GPIO_Pin_11)

#define LCD_SCLK(a)        if (a)        \
                                        GPIO_SetBits(GPIOB,GPIO_Pin_12);\
                                        else                \
                                        GPIO_ResetBits(GPIOB,GPIO_Pin_12)

#define LCD_PSB(a)        if (a)        \
                                        GPIO_SetBits(GPIOB,GPIO_Pin_13);\
                                        else                \
                                        GPIO_ResetBits(GPIOB,GPIO_Pin_13)

//#define LCD_RST(a)        if (a)        \
//                                        GPIO_SetBits(GPIOE,GPIO_Pin_11);\
//                                        else                \
//                                        GPIO_ResetBits(GPIOE,GPIO_Pin_11)



















/********************************************************/
/***12864驱动文件****************/
/********************************************************/
/********************************************************/
#include"lcd_12864.h"
#include "SYSTICK.h"

/********************************************************/
/********************************************************/
const unsigned char table1[]=" ADC值：";
const unsigned char table2[]="电压值：";
extern u16 adc,adc1;
u8 qian,bai,shi,ge;
u8 ADC_0,ADC_1,ADC_2,ADC_3,ADC_4;          
/********************************************************/
/********************************************************/
         /*LCD管脚配置*/
void LCD_GPIO_Config(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        /*开启GPIO的外设时钟*/
        RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB,ENABLE);
        /*选择要用的GPIO引脚*/
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   
    GPIO_Init(GPIOB, &GPIO_InitStructure);
}
/********************************************************/
/********************************************************/
  /*以串行协议发送数据*/
void send_bit(u8 byte)
{
        u8 x;
        for(x=0;x<8;x++)
        {
                if((byte<<x)&0x80)
                {
                        LCD_SID(UP);
                }
                else
                {
                        LCD_SID(DOWN);
                }
                LCD_SCLK(DOWN);
                LCD_SCLK(UP);
        }
        delay_ms(5);
}
/********************************************************/
/********************************************************/
        /*写指令函数*/
void write_command(u8 command)
{
        LCD_CS(UP);
    send_bit(0xf8);
    send_bit((u32)command&0xf0);
        send_bit(((u32)command<<4)&0xf0);
    delay_ms(5);
        LCD_CS(DOWN);
}
/********************************************************/
/********************************************************/
  /*液晶写数据功能函数函数*/
void write_data(const u8 Data)
{
        LCD_CS(UP);
        send_bit(0xfa);
        send_bit((u32)Data&0xf0);
        send_bit(((u32)Data<<4)&0xf0);
        delay_ms(5);
        LCD_CS(DOWN);
}
/********************************************************/
/********************************************************/
  /* 显示字符串   */
void write_zi( u8 *S)
{
while(*S!='\0')
   {
   write_data(*S);
   S++;
   delay_ms(5);
   }
}
/********************************************************/
/********************************************************/
  /*在指定位置写入字符串*/
void write_character(u8 address,const u8 *p)
{
        write_command(address);
        delay_ms(5);
        while(*p!='\0')
        {
                write_data(*p);
                p++;
                delay_ms(5);
        }
}

/********************************************************/

void lcd_pos(u8 X,u8 Y)          //液晶地址设置
  {
        u8 pos;
        if(X==0)
        {X=0x80;}
        else if(X==1)
        {X=0x90;}
        else if(X==2)
        {X=0x88;}
        else if(X==3)
        {X=0x98;}
        pos=X+Y;
        write_command(pos);
  }
/********************************************************/
  /*LCD 初始化设定*/
void LCD_init(void)
{
        LCD_PSB(DOWN);
        write_command(0x30);  //设置8位数据接口模式，基本指令操作模式
        delay_ms(1);
        write_command(0x0c);  //开显示，关光标，反白关
        delay_ms(1);
        write_command(0x01);        //写入空格清屏
        delay_ms(1);
        write_command(0x06);  //游标及显示右移一位
        delay_ms(1);   
}

void display_adc(void)
{
   
   qian=adc/1000;
   bai=adc%1000/100;
   shi=adc%100/10;
   ge=adc%10;

   ADC_0=adc1/10000;
   ADC_1=adc1%10000/1000;
   ADC_2=adc1%1000/100;
   ADC_3=adc1%100/10;
   ADC_3=adc1%10;
   
   write_character(0x80,table1);
   delay_ms(10);

   lcd_pos(0,4);
   write_data(qian+0x30);
   write_data(bai+0x30);
   write_data(shi+0x30);
   write_data(ge+0x30);

   write_character(0x88,table2);
   delay_ms(10);

   lcd_pos(2,4);
   write_data(ADC_0+0x30);
   write_zi(".");
   write_data(ADC_1+0x30);
   write_data(ADC_2+0x30);
   write_data(ADC_3+0x30);
   write_data(ADC_4+0x30);
   
}

tlsmf

额，代码好长。。。

NEWT

12864有好几种，有一种不带字库的默认就是画点的，如果要显示汉字要自己做字模
有一种带字库的默认是显示字，如果想要画点，需要该模式

songshanxiaozi

本坛魏坤示波器，有详细的程序可供参考
建议你移植ZLGGUI

marshallemon

玩过点阵LED就知道汉字怎么显示了，至于曲线，可以用画点实现，也可以用画线实现

shuiluo2

先驱动能显示一个点，再用画曲线的函数和字库来实现

zyj

qinshiysb 发表于 2013-10-29 08:51
/********************************************************/
/**************************************** ...

为什么用你的代码 液晶还是不显示  串行连接的

tigerman520

你的接线方式是什么？驱动程序是否正常。