代碼:

1. #include "msp430g2553.h"
   
2. #include "math.h"
   
3. #define SENDCOMM 0XF8     //0XF1000
   
4. #define READCOMM 0XFC     //0XF1100
   
5. #define SENDDATA 0XFA     //0XF1010
   
6. #define READDATA 0XFE     //0XF1110
   
7. /*-----12864串行定義--------*/
   
8. #define E_CLK_0  P1OUT &= ~BIT7         //時鐘信號為0
   
9. #define E_CLK_1  P1OUT |= BIT7                //時鐘信號為1
   
10. #define RW_SID_0  P1OUT &= ~BIT6        //數據信號為0
    
11. #define RW_SID_1  P1OUT |= BIT6                //數據信號為1
    
12. /*-----12864工作方式定義-------*/
    
13. #define EXTEND_SET 0x34//擴展指令集,繪圖顯示關
    
14. #define DRAW_ON 0x36 //繪圖顯示開
    
15. #define DRAW_OFF 0x34 //繪圖顯示關
    
16. #define BASIC_SET 0x30//基本指令集
    
17. 
    
18. #define FOSC 16000000
    
19. #define Machine_cycle 1.0/FOSC
    
20. #define Sound 340
    
21. /*------LCD12864基本函數-------*/
    
22. void LCD_send_byte(unsigned char a);
    
23. unsigned char LCD_read_byte();
    
24. void LCD_write_com(unsigned char comm);
    
25. void LCD_write_data(unsigned char lcd_data);
    
26. void LCD_set_addr(unsigned char x, unsigned char y);
    
27. void LCD_write_string(unsigned char addr_x, unsigned char addr_y, char* str);
    
28. void LCD_list_num(unsigned char x,unsigned char y,long number);
    
29. void LCD_list_Decimal(unsigned char x,unsigned char y,double Decimal);
    
30. void LCD_init(void);
    
31. void LCD_write_char(unsigned char x, unsigned char y,unsigned char flag, char data);
    
32. void LCD_clear(void);
    
33. unsigned char LCD_read_data();
    
34. void check_busy();
    
35. /*-----LCD12864繪圖函數-------*/
    
36. void GUI_clear();  //繪圖清屏函數 (清屏指令在畫圖時不能使用)
    
37. void GUI_draw_full_picture(const unsigned char *dat);//畫滿屏圖片，橫向取模
    
38. //void LCD_set_dot(unsigned char x,unsigned char y);//打點程序
    
39. //void GUI_hline(unsigned char x0,unsigned char x1,unsigned char y);//畫水平線函數,x0,x1為起始點和終點的水平坐標,y為垂直坐標
    
40. /*---------鍵盤函數---------*/
    
41. unsigned char getkey(void);
    
42. void GPIO_init();
    
43. void TIMER0_init();
    
44. void TIMER1_init();
    
45. void Calculation();
    
46. 
    
47. unsigned char num[] = {"0123456789ABCDEF"};
    
48. unsigned char key_t,key,t;
    
49. unsigned char odd;
    
50. unsigned long cap1_2=0;
    
51. unsigned long cap2_0=0;
    
52. unsigned long cap2_1=0;
    
53. unsigned long cap2_4=0;
    
54. unsigned int flag=0;
    
55. double x=0,y=0;
    
56. double X[20];
    
57. double Y[20];
    
58. 
    
59. void main(void) {
    
60.         WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
    
61.         DCOCTL=CALDCO_16MHZ;
    
62.         BCSCTL1=CALBC1_16MHZ;
    
63.         IFG1 &= ~OFIFG; // Clear OSCFault flag
    
64.         LCD_init();
    
65.         LCD_clear();
    
66.         GPIO_init();
    
67.         TIMER0_init();
    
68.         TIMER1_init();
    
69.         LCD_write_string(1,8,"坐標");
    
70.         _EINT();//開全局中斷
    
71.         while(1)
    
72.         {
    
73.                 if(cap1_2!=0)
    
74.                         if(cap2_0!=0)
    
75.                                 if(cap2_1!=0)
    
76.                                         if(cap2_4!=0)
    
77.                                         {
    
78.                                                 _DINT();
    
79.                                                 TA0CTL&=~MC_2;
    
80.                                                 TA1CTL&=~MC_2;
    
81.                                                 Calculation();
    
82.                                                 cap1_2=0;
    
83.                                                 cap2_0=0;
    
84.                                                 cap2_1=0;
    
85.                                                 cap2_4=0;
    
86.                                                 TA0CCR1=0x0000;
    
87.                                                 TA1CCR0=0x0000;
    
88.                                                 TA1CCR1=0x0000;
    
89.                                                 TA1CCR2=0x0000;
    
90.                                                 P1SEL&=~BIT2;
    
91.                                                 P1OUT&=~BIT2;
    
92.                                                 _delay_cycles(10);
    
93.                                                 P1IE|=BIT2;
    
94.                                                 _EINT();
    
95.                                         }
    
96.         }
    
97. }
    
98. //P1口外部中斷
    
99. #pragma vector=PORT1_VECTOR
    
100. __interrupt void Port_1(void)
     
101. {
     
102.         if(P1IFG&BIT2)
     
103.         {
     
104.                 P1OUT^=BIT0;
     
105.                 P1IE&=~BIT2;  //1.2禁止中斷
     
106.                 P1OUT|=BIT2; //1.2輸出
     
107.                 P1SEL|=BIT2; //p1.2外圍模塊功能
     
108.                 _delay_cycles(10);
     
109.                 TA0CTL|=MC_2+TACLR; //MC2連續(xù)計數   TACLR清除
     
110.                 TA1CTL|=MC_2+TACLR;
     
111.                 TA0CCTL1|=CM_2+CCIE;//CM選擇捕獲  CCIE中斷允許
     
112.                 TA1CCTL0|=CM_2+CCIE;
     
113.                 TA1CCTL1|=CM_2+CCIE;
     
114.                 TA1CCTL2|=CM_2+CCIE;
     
115.                 P1IFG&=~BIT2;        //P1.2無中斷請求
     
116.         }
     
117. }
     
118. 
     
119. // Timer A0 interrupt service routine
     
120. #pragma vector=TIMER0_A1_VECTOR                           //A1定時  R0計數
     
121. __interrupt void Timer0_A1(void)
     
122. {
     
123.         TA0CCTL1&=~CM_2;
     
124.         TA0CCTL1&=~CCIE;
     
125.         P1OUT^=BIT0;
     
126.         cap1_2=TA0CCR1;
     
127.         TA0CCTL1&=~CCIFG;
     
128. }
     
129. 
     
130. // Timer A1 interrupt service routine
     
131. #pragma vector=TIMER1_A0_VECTOR       
     
132. __interrupt void Timer1_A0(void)                                //A0定時  R1計數
     
133. {
     
134.         TA1CCTL0&=~CM_2;
     
135.         TA1CCTL0&=~CCIE;
     
136.         P1OUT^=BIT0;
     
137.         cap2_0=TA1CCR0;
     
138.         TA1CCTL0&=~CCIFG;
     
139. }
     
140. 
     
141. #pragma vector=TIMER1_A1_VECTOR                                //A1定時  R1計數
     
142. __interrupt void Timer1_A1(void)
     
143. {
     
144.         switch(TA1IV)
     
145.         {
     
146.         case TA1IV_TACCR1:
     
147.                 {
     
148.                         TA1CCTL1&=~CM_2;
     
149.                         TA1CCTL1&=~CCIE;
     
150.                         P1OUT^=BIT0;
     
151.                         cap2_1=TA1CCR1;
     
152.                         TA1CCTL1&=~CCIFG;
     
153.                         break;
     
154.                 }
     
155.         case TA1IV_TACCR2:
     
156.                 {
     
157.                         TA1CCTL2&=~CM_2;
     
158.                         TA1CCTL2&=~CCIE;
     
159.                         P1OUT^=BIT0;
     
160.                         cap2_4=TA1CCR2;
     
161.                         TA1CCTL2&=~CCIFG;
     
162.                         break;
     
163.                 }
     
164.         default:break;
     
165.         }
     
166. }
     
167. 
     
168. void GPIO_init()
     
169. {
     
170.         //標志口
     
171.         P1DIR|=BIT0;
     
172.         P1OUT&=~BIT0;
     
173.         _delay_cycles(20);
     
174.         //p1.2外部中斷設置
     
175.         P1DIR&=~BIT2;//輸入，上升沿觸發(fā)，開中斷
     
176.         P1REN|=BIT2;
     
177.         P1OUT&=~BIT2;
     
178.         P1IES&=~BIT2;
     
179.         P1IE|=BIT2;
     
180.         P1IFG&=~BIT2;
     
181.         _delay_cycles(20);
     
182.         //p2.0 p2.1 p2.4捕獲設置
     
183.         P2DIR&=~BIT0+BIT1+BIT4;//設置P2.0,2.1,2.4為輸入
     
184.         P2REN|=BIT0+BIT1+BIT4;
     
185.         P2OUT|=BIT0+BIT1+BIT4;
     
186.         P2SEL|=BIT0+BIT1+BIT4;
     
187.         _delay_cycles(20);
     
188. }
     
189. 
     
190. void TIMER0_init()
     
191. {
     
192.         TA0CTL |= TASSEL_2+MC_0+TACLR;
     
193.         TA0CCTL1|=CCIS_0+SCS+CAP+CM_0;
     
194. }
     
195. 
     
196. void TIMER1_init()
     
197. {
     
198.         TA1CTL |= TASSEL_2+MC_0+TACLR;
     
199.         TA1CCTL0|=CCIS_0+SCS+CAP+CM_0;
     
200.         TA1CCTL1|=CCIS_0+SCS+CAP+CM_0;
     
201.         TA1CCTL2|=CCIS_0+SCS+CAP+CM_0;
     
202. }
     
203. 
     
204. void Calculation()
     
205. {
     
206.         long a,b,c,d;
     
207.         double DA,DB,DC,DD;
     
208.         double x1,x2,y1,y2;
     
209.         DA=Sound*cap1_2*Machine_cycle*100.0;
     
210.         DB=Sound*cap2_0*Machine_cycle*100.0;
     
211.         DC=Sound*cap2_1*Machine_cycle*100.0;
     
212.         DD=Sound*cap2_4*Machine_cycle*100.0;
     
213.         x1=(DD*DD-DC*DC+250000*1.0)/(1000*1.0);
     
214.         x2=(DA*DA-DB*DB+250000*1.0)/(1000*1.0);
     
215.         y1=(DB*DB-DC*DC+122500*1.0)/(700*1.0);
     
216.         y2=(DA*DA-DD*DD+122500*1.0)/(700*1.0);
     
217.         if(flag<20)
     
218.         {
     
219.                 X[flag]=(x1+x2)*1.0/2.0;
     
220.                 Y[flag]=(y1+y2)*1.0/2.0;
     
221.                 flag++;
     
222.         }
     
223.         else
     
224.         {
     
225.                 for(flag=0;flag<20;flag++)
     
226.                 {
     
227.                         x=x+X[flag];
     
228.                         y=y+Y[flag];
     
229.                 }
     
230.                 x=x*1.0/20.0;
     
231.                 y=y*1.0/20.0;
     
232.                 LCD_list_Decimal(2,4,x);
     
233.                 LCD_list_Decimal(3,4,y);
     
234.                 flag=0;
     
235.         }
     
236. //        a=cap1_2-cap1_2;
     
237. //        b=cap2_0-cap1_2;
     
238. //        c=cap2_1-cap1_2;
     
239. //        d=cap2_4-cap1_2;
     
240. //        LCD_list_num(1,1,a);
     
241. //        LCD_list_num(2,1,b);
     
242. //        LCD_list_num(3,1,c);
     
243. //        LCD_list_num(4,1,d);
     
244.         LCD_list_num(1,1,cap1_2);
     
245.         LCD_list_num(2,1,cap2_0);
     
246.         LCD_list_num(3,1,cap2_1);
     
247.         LCD_list_num(4,1,cap2_4);
     
248. }
     
249. /*---------鍵盤函數---------*/
     
250. unsigned char getkey(void) //獲得鍵盤的值
     
251. {
     
252.         P1REN |= BIT3 + BIT4 + BIT5;
     
253.         P1DIR &= ~(BIT3 + BIT4 + BIT5);
     
254.         P1OUT |= BIT3 + BIT4 + BIT5; //00111000
     
255.         t = (P1IN & 0x38)/8;
     
256.         if (t == 0x07) {
     
257.                 P1REN |= BIT4 + BIT5;
     
258.                 P1REN &= ~BIT3;
     
259.                 P1DIR |= BIT3 + BIT4 + BIT5;
     
260.                 P1OUT |= BIT4 + BIT5; //00110000
     
261.                 P1OUT &= ~BIT3;
     
262.                 P1DIR &= ~(BIT4 + BIT5);
     
263.                 t = P1IN & 0x038;
     
264.                 t = (t/8) / 2 + 7;
     
265.                 if (t == 0x0a) {
     
266.                         P1REN |= BIT5 + BIT3;
     
267.                         P1REN &= ~BIT4;
     
268.                         P1DIR |= BIT3 + BIT4 + BIT5;
     
269.                         P1OUT |= BIT3+BIT5; //00101000
     
270.                         P1OUT &= ~BIT4;
     
271.                         P1DIR &= ~(BIT3 + BIT5);
     
272.                         t = P1IN & 0x38;
     
273.                         t = ((t/8) + 1) / 2 + 10;
     
274.                         if (t == 0x0d) {
     
275.                                 P1REN |= BIT3 + BIT4;
     
276.                                 P1REN &= ~BIT5;
     
277.                                 P1DIR |= BIT3 + BIT4 + BIT5;
     
278.                                 P1OUT |= BIT3+BIT4; //00011000
     
279.                                 P1OUT &= ~BIT5;
     
280.                                 P1DIR &= ~(BIT3 + BIT4);
     
281.                                 t = P1IN & 0x38;
     
282.                                 t =(t/8)+13;
     
283.                         }
     
284.                 }
     
285.         }
     
286.         return (t);
     
287. }
     
288. 
     
289. void show_key()//顯示鍵盤的值
     
290. {
     
291.         key_t=getkey();
     
292.         if(key_t!=16)
     
293.         {
     
294.                 _delay_cycles(20000);
     
295.                 key=getkey();
     
296.                 if(key==key_t)
     
297.                 {
     
298.                         while(1)
     
299.                         {
     
300.                                 key_t=getkey();
     
301.                                 if(key_t==16)
     
302.                                         break;
     
303.                         }
     
304.                 }
     
305.                 else
     
306.                 {
     
307.                         key=16;
     
308.                 }
     
309.                 if(key==15)
     
310.                         LCD_clear();
     
311.                 else
     
312.                         LCD_write_char(1, 2,0,num[key]);
     
313.                 _delay_cycles(200000);
     
314.         }
     
315. }
     
316. 
     
317. /*------LCD12864基本函數-------*/
     
318. void check_busy()
     
319. {
     
320.         do
     
321.         {
     
322.                 LCD_send_byte(READCOMM);
     
323.         }
     
324.         while(LCD_read_byte()&0x80);
     
325. }
     
326. 
     
327. void LCD_send_byte(unsigned char a) {
     
328.         unsigned char i=0;
     
329.         for (i = 8; i > 0; i--) {
     
330.                 if (a & (0x01 << (i - 1)))
     
331.                         RW_SID_1;
     
332.                 else
     
333.                         RW_SID_0;
     
334.                 _delay_cycles(100);
     
335.                 E_CLK_1;
     
336.                 _delay_cycles(100);
     
337.                 E_CLK_0;
     
338.                 _delay_cycles(100);
     
339.         }
     
340. }
     
341. 
     
342. unsigned char LCD_read_byte()
     
343. {
     
344.         unsigned char i,j,temp1=0;
     
345.         _delay_cycles(100);
     
346.         P1DIR&=~BIT6;
     
347.         RW_SID_1;
     
348.         for(j=0;j<2;j++)
     
349.         {
     
350.                 for(i=0;i<4;i++)
     
351.                 {
     
352.                         if(P1IN&BIT6) temp1|=0x01;
     
353.                         else temp1&=~0x01;
     
354.                         temp1<<=1;
     
355.                         E_CLK_0;
     
356.                         _delay_cycles(100);
     
357.                         E_CLK_1;
     
358.                         _delay_cycles(100);
     
359.                         E_CLK_0;
     
360.                         _delay_cycles(100);
     
361.                 }
     
362.                 for(i=0;i<4;i++)
     
363.                 {
     
364.                         E_CLK_0;
     
365.                         _delay_cycles(100);
     
366.                         E_CLK_1;
     
367.                         _delay_cycles(100);
     
368.                         E_CLK_0;
     
369.                         _delay_cycles(100);
     
370.                 }
     
371.         }
     
372.         P1DIR|=BIT6;
     
373.         return temp1;
     
374. }
     
375. 
     
376. unsigned char LCD_read_data()
     
377. {
     
378.         unsigned char temp;
     
379.         LCD_send_byte(READDATA);
     
380.         _delay_cycles(1000);
     
381.         temp=LCD_read_byte();
     
382.         return temp;
     
383. }
     
384. 
     
385. void LCD_write_com(unsigned char comm) {
     
386.         unsigned char temp;
     
387.         check_busy();
     
388.         _delay_cycles(100);
     
389. 
     
390.         LCD_send_byte(SENDCOMM); //MCU to LCD, command
     
391. 
     
392.         temp = comm & 0XF0;
     
393.         LCD_send_byte(temp); //send high 4 bits
     
394. 
     
395.         temp = ((comm & 0X0F) << 4) & 0XF0;
     
396.         LCD_send_byte(temp); //send low 4 bits
     
397. 
     
398.         _delay_cycles(100);
     
399. 
     
400. }
     
401. 
     
402. void LCD_write_data(unsigned char lcd_data) //寫數據
     
403. {
     
404.         unsigned char temp;
     
405.         check_busy();
     
406.         _delay_cycles(100);
     
407.         LCD_send_byte(SENDDATA);
     
408. 
     
409.         temp = lcd_data & 0xf0;
     
410.         LCD_send_byte(temp);
     
411. 
     
412.         temp = (lcd_data & 0X0F) << 4;
     
413.         LCD_send_byte(temp);
     
414. 
     
415.         _delay_cycles(100);
     
416. 
     
417. }
     
418. 
     
419. void LCD_set_addr(unsigned char x, unsigned char y) //設置顯示位置
     
420. {
     
421.         if(y%2==0) odd=0;
     
422.         else odd=1;
     
423.         y=(y+1)/2;
     
424.         switch (x) {
     
425.         case 1:
     
426.                 LCD_write_com(0X7F + y);
     
427.                 break;
     
428.         case 2:
     
429.                 LCD_write_com(0X8F + y);
     
430.                 break;
     
431.         case 3:
     
432.                 LCD_write_com(0X87 + y);
     
433.                 break;
     
434.         case 4:
     
435.                 LCD_write_com(0X97 + y);
     
436.                 break;
     
437.         default:
     
438.                 break;
     
439.         }
     
440. }
     
441. 
     
442. void LCD_write_char(unsigned char x, unsigned char y,unsigned char flag, char data)
     
443. {
     
444.         LCD_set_addr(x, y);
     
445.         if(odd==0)
     
446.         {
     
447.                 if(flag==1)
     
448.                 {
     
449.                         LCD_read_data();
     
450.                         LCD_set_addr(x,y);
     
451.                         LCD_write_data(data);
     
452.                 }
     
453.         }
     
454.         LCD_write_data(data);
     
455. }
     
456. 
     
457. void LCD_write_string(unsigned char addr_x, unsigned char addr_y, char* str) {
     
458.         unsigned char LCD_temp;
     
459.         LCD_set_addr(addr_x, addr_y);
     
460.         if(odd==0)
     
461.         {
     
462.                 LCD_read_data();
     
463.                 LCD_set_addr(addr_x,addr_y);
     
464.                 LCD_write_data(*str++);
     
465.         }
     
466.         LCD_temp = *str;
     
467.         while (LCD_temp != 0x00) {
     
468.                 LCD_write_data(LCD_temp);
     
469.                 LCD_temp = *(++str);
     
470.         }
     
471. }
     
472. 
     
473. void LCD_list_num(unsigned char x,unsigned char y,long number)
     
474. {
     
475.         unsigned char pos;
     
476.         switch (x)
     
477.         {
     
478.                 case 1:
     
479.                         x=0x7F;
     
480.                         break;
     
481. 
     
482.                 case 2:
     
483.                         x=0x8F;
     
484.                         break;
     
485. 
     
486.                 case 3:
     
487.                         x=0x87;
     
488.                         break;
     
489. 
     
490.                 case 4:
     
491.                         x=0x97;
     
492.                         break;
     
493.         }
     
494.         pos=x+y;
     
495.         LCD_write_com(pos);
     
496.         if(number<=-100000&&number>-1000000)
     
497.         {
     
498.                 LCD_write_data(0x30+(-number)/100000);
     
499.                 LCD_write_data(0x30+((-number)/10000)%10);
     
500.                 LCD_write_data(0x30+((-number)/1000)%10);
     
501.                 LCD_write_data(0x30+((-number)/100)%10);
     
502.                 LCD_write_data(0x30+((-number)/10)%10);
     
503.                 LCD_write_data(0x30+(-number)%10);
     
504.         }
     
505.         if(number<=-10000&&number>-100000)
     
506.         {
     
507.                 LCD_write_data(0x30+(-number)/10000);
     
508.                 LCD_write_data(0x30+((-number)/1000)%10);
     
509.                 LCD_write_data(0x30+((-number)%1000)/100);
     
510.                 LCD_write_data(0x30+((-number)%100)/10);
     
511.                 LCD_write_data(0x30+(-number)%10);
     
512.         }
     
513.         if(number<=-1000&&number>-10000)
     
514.         {
     
515.                 LCD_write_data('-');
     
516.                 LCD_write_data(0x30+(-number)/1000);
     
517.                 LCD_write_data(0x30+((-number)/100)%10);
     
518.                 LCD_write_data(0x30+((-number)%100)/10);
     
519.                 LCD_write_data(0x30+(-number)%10);
     
520.         }
     
521.         if(number<=-100&&number>-1000)
     
522.         {
     
523.                 LCD_write_data('-');
     
524.                 LCD_write_data(0x30+(-number)/100);
     
525.                 LCD_write_data(0x30+((-number)/10)%10);
     
526.                 LCD_write_data(0x30+(-number)%10);
     
527.         }
     
528.         if(number<=-10&&number>-100)
     
529.         {
     
530.                 LCD_write_data('-');
     
531.                 LCD_write_data(0x30+(-number)/10);
     
532.                 LCD_write_data(0x30+(-number)%10);
     
533.         }
     
534.         if(number<0&&number>-10)
     
535.         {
     
536.                 LCD_write_data('-');
     
537.                 LCD_write_data(0x30+(-number)%10);
     
538.         }
     
539.         if(number>=0&&number<10)
     
540.         {
     
541.                 LCD_write_data(0x30+number%10);
     
542.         }
     
543.         if(number>=10&&number<100)
     
544.         {
     
545.                 LCD_write_data(0x30+number/10);
     
546.                 LCD_write_data(0x30+number%10);
     
547.         }
     
548.         if(number>=100&&number<1000)
     
549.         {
     
550.                 LCD_write_data(0x30+number/100);
     
551.                 LCD_write_data(0x30+(number/10)%10);
     
552.                 LCD_write_data(0x30+number%10);
     
553.         }
     
554.         if(number>=1000&&number<10000)
     
555.         {
     
556.                 LCD_write_data(0x30+number/1000);
     
557.                 LCD_write_data(0x30+(number/100)%10);
     
558.                 LCD_write_data(0x30+(number%100)/10);
     
559.                 LCD_write_data(0x30+number%10);
     
560.         }
     
561.         if(number>=10000&&number<100000)
     
562.         {
     
563.                 LCD_write_data(0x30+number/10000);
     
564.                 LCD_write_data(0x30+(number/1000)%10);
     
565.                 LCD_write_data(0x30+(number%1000)/100);
     
566.                 LCD_write_data(0x30+(number%100)/10);
     
567.                 LCD_write_data(0x30+number%10);
     
568.         }
     
569.         if(number>=100000&&number<1000000)
     
570.         {
     
571.                 LCD_write_data(0x30+number/100000);
     
572.                 LCD_write_data(0x30+(number/10000)%10);
     
573.                 LCD_write_data(0x30+(number/1000)%10);
     
574.                 LCD_write_data(0x30+(number/100)%10);
     
575.                 LCD_write_data(0x30+(number/10)%10);
     
576.                 LCD_write_data(0x30+number%10);
     
577.         }
     
578.         if(number>=1000000&&number<10000000)
     
579.         {
     
580.                 LCD_write_data(0x30+number/1000000);
     
581.                 LCD_write_data(0x30+(number/100000)%10);
     
582.                 LCD_write_data(0x30+(number/10000)%10);
     
583.                 LCD_write_data(0x30+(number/1000)%10);
     
584.                 LCD_write_data(0x30+(number/100)%10);
     
585.                 LCD_write_data(0x30+(number/10)%10);
     
586.                 LCD_write_data(0x30+number%10);
     
587.         }
     
588. }
     
589. 
     
590. void LCD_list_Decimal(unsigned char x,unsigned char y,double Decimal)
     
591. {
     
592.         unsigned char pos;
     
593.         double Deci;
     
594.         unsigned long num;
     
595.         num=(unsigned long)Decimal;
     
596.         Deci=Decimal-num;
     
597.         switch (x)
     
598.         {
     
599.                 case 1:
     
600.                         x=0x7F;
     
601.                         break;
     
602. 
     
603.                 case 2:
     
604.                         x=0x8F;
     
605.                         break;
     
606. 
     
607.                 case 3:
     
608.                         x=0x87;
     
609.                         break;
     
610. 
     
611.                 case 4:
     
612.                         x=0x97;
     
613.                         break;
     
614.         }
     
615.         pos=x+y;
     
616.         LCD_write_com(pos);
     
617.         if(Decimal>=0 && Decimal<1)
     
618.         {
     
619.                 LCD_write_data(0x30+0);
     
620.                 LCD_write_data('.');
     
621.                 LCD_write_data(0x30+(int)(Deci*10)%10);
     
622.                 LCD_write_data(0x30+(int)(Deci*100)%10);
     
623.                 LCD_write_data(0x30+(int)(Deci*1000)%10);
     
624.                 LCD_write_data(0x30+(int)(Deci*10000)%10);
     
625.                 LCD_write_data(0x30+(int)(Deci*100000)%10);
     
626.         }
     
627.         if(Decimal>=1 && Decimal<10)
     
628.         {
     
629.                 LCD_write_data(0x30+num%10);
     
630.                 LCD_write_data('.');
     
631.                 LCD_write_data(0x30+(int)(Deci*10)%10);
     
632.                 LCD_write_data(0x30+(int)(Deci*100)%10);
     
633.                 LCD_write_data(0x30+(int)(Deci*1000)%10);
     
634.                 LCD_write_data(0x30+(int)(Deci*10000)%10);
     
635.                 LCD_write_data(0x30+(int)(Deci*100000)%10);
     
636.         }
     
637.         if(Decimal>=10 && Decimal<100)
     
638.         {
     
639.                 LCD_write_data(0x30+num/10);
     
640.                 LCD_write_data(0x30+num%10);
     
641.                 LCD_write_data('.');
     
642.                 LCD_write_data(0x30+(int)(Deci*10)%10);
     
643.                 LCD_write_data(0x30+(int)(Deci*100)%10);
     
644.                 LCD_write_data(0x30+(int)(Deci*1000)%10);
     
645.                 LCD_write_data(0x30+(int)(Deci*10000)%10);
     
646.                 LCD_write_data(0x30+(int)(Deci*100000)%10);
     
647.         }
     
648.         if(Decimal>=100 && Decimal<1000)
     
649.         {
     
650.                 LCD_write_data(0x30+num/100);
     
651.                 LCD_write_data(0x30+num/10%10);
     
652.                 LCD_write_data(0x30+num%10);
     
653.                 LCD_write_data('.');
     
654.                 LCD_write_data(0x30+(int)(Deci*10)%10);
     
655.                 LCD_write_data(0x30+(int)(Deci*100)%10);
     
656.                 LCD_write_data(0x30+(int)(Deci*1000)%10);
     
657.                 LCD_write_data(0x30+(int)(Deci*10000)%10);
     
658.                 LCD_write_data(0x30+(int)(Deci*100000)%10);
     
659.         }
     
660.         if(Decimal>=1000 && Decimal<10000)
     
661.         {
     
662.                 LCD_write_data(0x30+num/1000);
     
663.                 LCD_write_data(0x30+num/100%10);
     
664.                 LCD_write_data(0x30+num/10%10);
     
665.                 LCD_write_data(0x30+num%10);
     
666.                 LCD_write_data('.');
     
667.                 LCD_write_data(0x30+(int)(Deci*10)%10);
     
668.                 LCD_write_data(0x30+(int)(Deci*100)%10);
     
669.                 LCD_write_data(0x30+(int)(Deci*1000)%10);
     
670.                 LCD_write_data(0x30+(int)(Deci*10000)%10);
     
671.                 LCD_write_data(0x30+(int)(Deci*100000)%10);
     
672.         }
     
673. }
     
674. 
     
675. void LCD_init(void) {
     
676.         P1DIR |= BIT6 + BIT7;
     
677.         _delay_cycles(2000);
     
678.         LCD_write_com(0x30); //一次送8位數據
     
679.         LCD_write_com(0x0C); //整體顯示，游標off，游標位置off
     
680.         LCD_write_com(0x01); //清DDRAM
     
681.         LCD_write_com(0x02); //DDRAM地址歸位
     
682.         LCD_write_com(0x80); //設定DDRAM 7位地址000，0000到地址計數器AC
     
683. }
     
684. 
     
685. void LCD_clear(void){
     
686.         LCD_write_com(0x01);
     
687. }
     
688. 
     
689. /*-----LCD12864繪圖函數-------*/
     
690. void GUI_clear()  //繪圖清屏函數 (清屏指令在畫圖時不能使用)
     
691. {
     
692.         unsigned char i,j,k;
     
693.         LCD_write_com(EXTEND_SET);//擴展指令集，8位數據傳輸，繪圖開
     
694.         LCD_write_com(DRAW_OFF);        //關閉繪圖顯示
     
695.         for(i=0;i<2;i++)  //分上下兩屏寫
     
696.         {
     
697.                 for(j=0;j<32;j++)
     
698.                 {
     
699.                         LCD_write_com(0x80+j);        //寫y坐標
     
700.                         _delay_cycles(10);
     
701.                         if(i==0)//寫x坐標
     
702.                         {
     
703.                                 LCD_write_com(0x80);
     
704.                                 _delay_cycles(100);
     
705.                         }
     
706.                         else
     
707.                         {
     
708.                                 LCD_write_com(0x88);
     
709.                                 _delay_cycles(100);
     
710.                         }
     
711.                         for(k=0;k<16;k++)  //寫一整行數據
     
712.                         {
     
713.                                 LCD_write_data(0x00);  //寫高字節(jié)
     
714.                                 LCD_write_data(0x00);  //寫低字節(jié)
     
715.                                 _delay_cycles(100);
     
716.                         }
     
717.                 }
     
718.         }
     
719.         LCD_write_com(DRAW_ON);        //打開繪圖顯示
     
720.         LCD_write_com(BASIC_SET);//打開基本指令集
     
721. }
     
722. 
     
723. void GUI_draw_full_picture(const unsigned char *dat)//畫滿屏圖片，橫向取模
     
724. {
     
725.            unsigned char i,j,k;
     
726.            unsigned char GDRAMAddrX=0x80;
     
727.            unsigned char GDRAMAddrY=0x80;
     
728.            for(i=0;i<2;i++)
     
729.            {
     
730.                            for(j=0;j<32;j++)
     
731.                         {
     
732.                                 for(k=0;k<8;k++)
     
733.                                 {
     
734.                                         LCD_write_com(DRAW_OFF);
     
735.                                         LCD_write_com(GDRAMAddrY+j);
     
736.                                         LCD_write_com(GDRAMAddrX+k);
     
737.                                         LCD_write_data(*dat++);
     
738.                                         LCD_write_data(*dat++);
     
739.                                 }
     
740.                         }
     
741.                         GDRAMAddrX=0x88;
     
742.            }
     
743.            LCD_write_com(DRAW_ON);
     
744.            LCD_write_com(BASIC_SET);
     
745. }
     
746. 
     
747. /*
     
748. void LCD_set_dot(unsigned char x,unsigned char y)//打點程序
     
749. {
     
750.          unsigned char x_byte,x_bit;  //確定在坐標的那一字節(jié)哪一位
     
751.          unsigned char y_byte,y_bit;  //確定在坐標的哪一屏哪一行
     
752.          unsigned char temph,templ;         //定義兩個臨時變量，用于存放讀出來的數據
     
753.          LCD_write_com(EXTEND_SET);        //擴展指令集
     
754.          LCD_write_com(DRAW_OFF);//繪圖顯示關閉
     
755.          x_byte=x/16;
     
756.          x_bit=x%16;
     
757.          y_byte=y/32;
     
758.          y_bit=y%32;
     
759.          LCD_write_com(EXTEND_SET);
     
760.          LCD_write_com(0x80+y_bit);
     
761.          LCD_write_com(0x80+x_byte+8*y_byte);
     
762.          LCD_read_byte();
     
763.          temph=LCD_read_byte();
     
764.          templ=LCD_read_byte();
     
765.          _delay_cycles(10);
     
766.          LCD_write_com(0x80+y_bit);
     
767.          LCD_write_com(0x80+x_byte+8*y_byte);
     
768.          _delay_cycles(10);
     
769.          if(x_bit<8)
     
770.          {
     
771.                  LCD_write_data(temph|(0x01<<(7-x_bit)));
     
772.                 LCD_write_data(templ);
     
773.          }
     
774.          else
     
775.          {
     
776.                  LCD_write_data(temph);
     
777.                 LCD_write_data(templ|(0x01<<(15-x_bit)));
     
778.          }
     
779.          LCD_write_com(DRAW_ON);
     
780.          LCD_write_com(BASIC_SET);
     
781. }
     
782. */