帆板运动（adxl3+有字库1268+51单片机+矩阵键盘）源程序

帆板运动（adxl3+有字库1268+51单片机+矩阵键盘）

下载：

帆板.docx (24.59 KB, 下载次数: 13)

2017-7-19 15:14 上传

点击文件名下载附件

1. 
   
2. /***************************************************************/
   
3. #include<reg51.h>
   
4. #include "control.h"
   
5. #include "12864.h"
   
6. #include "adxl.h"
   
7. #define uchar unsigned char
   
8. #define uint unsigned int
   
9. sbit key=P2^3;
   
10. void timer_init()
    
11. {   
    
12.   TMOD=0X10;  
    
13.   TH1=(65535-100)/256;
    
14.   TL1=(65535-100)%256;
    
15.   EA=1;
    
16.   ET1=1;
    
17.   TR1=1;
    
18. }  
    
19. void main()
    
20. {  
    
21. char devid;
    
22. timer_init();
    
23. lcd_12864_init();
    
24. Init_ADXL345();                  //初始化ADXL345  
    
25. devid=Single_Read_ADXL345(0X00); //读出的数据为0XE5,表示正确  
    
26.   while(1)
    
27.         {   
    
28.          adxl345();   
    
29.           if(key==0)  
    
30.          keyscan_1();
    
31.           else   
    
32.          keyscan();   
    
33.     }
    
34. }   
    
35.   /*********************************
    
36. 
    
37. 
    
38. 
    
39. 
    
40. 
    
41. 
    
42. //  Controh.H文件
    
43. #ifndef __contral_h_  
    
44. #define __contral_h_
    
45. extern signed char pwm;
    
46. extern void delayms(unsigned int xms);          
    
47. extern void keyscan();
    
48. extern void keyscan_1();
    
49. #endif
    
50. 
    
51. 
    
52. 
    
53. 
    
54. 
    
55. 
    
56. 
    
57. //12864.H文件
    
58. #ifndef __12864_h_  
    
59. #define __12864_h_
    
60. extern void lcd_writestring(unsigned char *str); //向lcd发送一个字符串,长度64字符之内。         /**/
    
61. extern void write_12864_cmd(unsigned char cmd ); //向液晶写数据
    
62. extern void write_12864_data(unsigned char dat); //向液晶写数据?
    
63. extern void lcd_12864_init();//初始化液晶
    
64. extern void write_12864_addr(unsigned char x,unsigned char y); //写液晶的地址
    
65. extern void delayms_12864(unsigned char xms); //延时函数
    
66. extern void write_12864_addr(unsigned char x,unsigned char y);//写液晶的地址
    
67. #endif
    
68. 
    
69. 
    
70. 
    
71. 
    
72. 
    
73. 
    
74. //ADXL.H文件
    
75. #ifndef __ADXL_h_  
    
76. #define __ADXL_h_
    
77. 
    
78. extern void jiaodu();   //角度转换          /**/
    
79. extern void display_x();     //x轴           /**/
    
80. extern void display_y();     //y轴           /**/
    
81. extern void display_z();    //z轴           /**/
    
82. extern void Init_ADXL345();     //延时函数  
    
83. extern unsigned char Single_Read_ADXL345(unsigned char REG_Address);
    
84. extern void Multiple_read_ADXL345(void);  /**/
    
85. extern void adxl345();
    
86. 
    
87. #endif
    
88. 
    
89. 
    
90. 
    
91. 
    
92. 
    
93. 
    
94. //  Controh.H文件
    
95. //#ifndef __contral_h_  
    
96. //#define __contral_h_
    
97. //extern signed char pwm;
    
98. //extern void delayms(unsigned int xms);          
    
99. //extern void keyscan();
    
100. //extern void keyscan_1();
     
101. //#endif
     
102. /***************************************************************/
     
103. // Control.C文件
     
104. #include<reg51.h>
     
105. #include "control.h"
     
106. #include "12864.h"  
     
107. #define uchar unsigned char
     
108. #define uint unsigned int
     
109. #define keydata P1
     
110. sbit A1=P1^4;
     
111. sbit A2=P1^5;
     
112. sbit ENA=P1^6;
     
113. signed int count=0;  
     
114. signed char pwm=0;
     
115. signed char anjian=0;
     
116. uchar numshi=0;
     
117. uchar numge=0;  
     
118. void delayms(unsigned int xms)
     
119. {   
     
120.   unsigned int i,j;  
     
121.   for(i=0;i<xms;i++)   
     
122.   for(j=0;j<110;j++);  
     
123. }   
     
124. void pwm_dis()
     
125. {   
     
126.   numshi=pwm/10;
     
127.   numge=pwm%10;  
     
128.   write_12864_data(0x30+numshi);
     
129.   write_12864_data(0x30+numge);  
     
130. }   
     
131. void anjian_dis()
     
132. {   
     
133.   numshi=anjian/10;
     
134.   numge=anjian%10;  
     
135.   write_12864_data(0x30+numshi);
     
136.   write_12864_data(0x30+numge);
     
137. }
     
138. void keyscan()
     
139. {   
     
140.   unsigned char dat=0;
     
141.   unsigned char num=0;   
     
142.   keydata=0xfe;   
     
143.   dat=keydata;   
     
144.   dat=dat&0xf0;   
     
145.   while(dat!=0xf0)   
     
146.    {     
     
147.      delayms(5);     
     
148.          dat=keydata;   
     
149.      dat=dat&0xf0;     
     
150.          while(dat!=0xf0)   
     
151.           {      
     
152.             dat=keydata;   
     
153.              switch(dat)      
     
154.                   {      
     
155.                     case 0xee:num=1;        
     
156.                                   break;      
     
157.                     case 0xde:num=2;        
     
158.                                   break;      
     
159.                     case 0xbe:num=3;      
     
160.                               break;      
     
161.                     case 0x7e:num=4;        
     
162.                                   break;      
     
163.                   }     
     
164.              while(dat!=0xf0)     
     
165.               {        
     
166.                     dat=keydata;      
     
167.                     dat=dat&0xf0;   
     
168.               }           
     
169.           }   
     
170.     }     
     
171.   keydata=0xfd;  
     
172.   dat=keydata;
     
173.   dat=dat&0xf0;   
     
174.   while(dat!=0xf0)     
     
175.    {      
     
176.     delayms(5);     
     
177.     dat=keydata;     
     
178.     dat=dat&0xf0;      
     
179.     while(dat!=0xf0)     
     
180.          {      
     
181.           dat=keydata;     
     
182.           switch(dat)      
     
183.            {      
     
184.             case 0xed:num=5;        
     
185.                       break;      
     
186.             case 0xdd:num=6;         
     
187.                           break;        
     
188.                 case 0xbd:num=7;         
     
189.                           break;        
     
190.                 case 0x7d:num=8;         
     
191.                           break;      
     
192.            }      
     
193.         while(dat!=0xf0)      
     
194.           {        
     
195.            dat=keydata;        
     
196.            dat=dat&0xf0;      
     
197.           }            
     
198.          }     
     
199.    }        
     
200.     keydata=0xfb;   
     
201.         dat=keydata;   
     
202.         dat=dat&0xf0;   
     
203.         while(dat!=0xf0)     
     
204.          {      
     
205.           delayms(5);      
     
206.           dat=keydata;      
     
207.           dat=dat&0xf0;      
     
208.           while(dat!=0xf0)      
     
209.            {      
     
210.             dat=keydata;     
     
211.           switch(dat)        
     
212.            {
     
213.                  case 0xeb:num=9;         
     
214.                            break;        
     
215.                  case 0xdb:num=10;         
     
216.                            break;        
     
217.                  case 0xbb:num=11;         
     
218.                            break;        
     
219.                  case 0x7b:num=12;         
     
220.                            break;      
     
221.            }      
     
222.           while(dat!=0xf0)      
     
223.            {        
     
224.             dat=keydata;        
     
225.                 dat=dat&0xf0;      
     
226.                 }            
     
227.            }     
     
228.          }
     
229. 
     
230.    
     
231.   keydata=0xf7;   
     
232.   dat=keydata;   
     
233.   dat=dat&0xf0;   
     
234.    while(dat!=0xf0)     
     
235.     {      
     
236.          delayms(5);      
     
237.          dat=keydata;      
     
238.          dat=dat&0xf0;      
     
239.      while(dat!=0xf0)      
     
240.       {      
     
241.            dat=keydata;      
     
242.          switch(dat)      
     
243.           {        
     
244.            case 0xe7:num=13;         
     
245.                      break;        
     
246.            case 0xd7:num=14;         
     
247.                      break;        
     
248.            case 0xb7:num=15;         
     
249.                      break;        
     
250.            case 0x77:num=16;         
     
251.                      break;      
     
252.           }      
     
253.          while(dat!=0xf0)        
     
254.           {
     
255.            dat=keydata;        
     
256.            dat=dat&0xf0;      
     
257.           }            
     
258.           }      
     
259.         }
     
260.   switch(num)  
     
261.    {   
     
262.     case 1:write_12864_addr(1,3);     
     
263.                pwm=0;     
     
264.                pwm_dis();     
     
265.                break;   
     
266.         case 2:write_12864_addr(1,3);     
     
267.                pwm=10;     
     
268.                pwm_dis();     
     
269.                break;   
     
270.         case 3:write_12864_addr(1,3);     
     
271.                pwm=20;     
     
272.            pwm_dis();     
     
273.                break;   
     
274.         case 4:write_12864_addr(1,3);     
     
275.                    pwm=30;     
     
276.                    pwm_dis();     
     
277.                    break;
     
278.                             
     
279.         case 5:write_12864_addr(1,3);     
     
280.                pwm=40;     
     
281.                pwm_dis();     
     
282.                break;   
     
283.         case 6:write_12864_addr(1,3);     
     
284.                pwm=50;     
     
285.                pwm_dis();     
     
286.                break;   
     
287.         case 7:write_12864_addr(1,3);     
     
288.                pwm=60;     
     
289.                pwm_dis();     
     
290.                break;
     
291.         case 8:write_12864_addr(1,3);     
     
292.                pwm=70;     
     
293.                pwm_dis();      
     
294.                break;
     
295.     case 9:write_12864_addr(1,3);     
     
296.                pwm=80;     
     
297.                pwm_dis();     
     
298.                break;           
     
299.         case 10:write_12864_addr(1,3);     
     
300.                 pwm=90;     
     
301.                 pwm_dis();         
     
302.                 break;  
     
303.         case 11:write_12864_addr(1,3);         
     
304.                 pwm=99;     
     
305.                 pwm_dis();     
     
306.                 break;   
     
307.         case 12:write_12864_addr(1,3);         
     
308.                 pwm=35;     
     
309.                 pwm_dis();     
     
310.                 break;   
     
311.         case 13:write_12864_addr(1,3);     
     
312.                 pwm=pwm+5;     
     
313.                         pwm_dis();     
     
314.                         break;   
     
315.         case 14:write_12864_addr(1,3);         
     
316.                 pwm=pwm-5;     
     
317.                         pwm_dis();     
     
318.                         break;   
     
319.         case 15:write_12864_addr(1,3);   
     
320.                 pwm=pwm+1;     
     
321.                         pwm_dis();     
     
322.                         break;   
     
323.         case 16:write_12864_addr(1,3);     
     
324.                 pwm=pwm-1;     
     
325.                         pwm_dis();     
     
326.                         break;   
     
327.    }
     
328. }  
     
329. void keyscan_1()
     
330. {   
     
331.   unsigned char dat=0;   
     
332.   unsigned char num=0;   
     
333.    keydata=0xfe;   
     
334.    dat=keydata;   
     
335.    dat=dat&0xf0;   
     
336.    while(dat!=0xf0)     
     
337.     {      
     
338.          delayms(5);      
     
339.          dat=keydata;      
     
340.          dat=dat&0xf0;      
     
341.          while(dat!=0xf0)      
     
342.           {      
     
343.            dat=keydata;      
     
344.          switch(dat)      
     
345.           {        
     
346.            case 0xee:num=1;         
     
347.                      break;        
     
348.            case 0xde:num=2;        
     
349.                      break;        
     
350.            case 0xbe:num=3;        
     
351.                      break;        
     
352.            case 0x7e:num=4;         
     
353.                      break;      
     
354.            }      
     
355.          while(dat!=0xf0)      
     
356.              {        
     
357.                    dat=keydata;        
     
358.                    dat=dat&0xf0;      
     
359.                  }            
     
360.           }     
     
361.          }     
     
362.         keydata=0xfd;   
     
363.         dat=keydata;   
     
364.         dat=dat&0xf0;   
     
365.         while(dat!=0xf0)  
     
366.           {
     
367.             delayms(5);      
     
368.                 dat=keydata;      
     
369.                 dat=dat&0xf0;      
     
370.                 while(dat!=0xf0)      
     
371.                  {      
     
372.                   dat=keydata;      
     
373.                 switch(dat)      
     
374.                  {        
     
375.                   case 0xed:num=5;         
     
376.                             break;        
     
377.                   case 0xdd:num=6;         
     
378.                             break;        
     
379.                   case 0xbd:num=7;         
     
380.                             break;        
     
381.                   case 0x7d:num=8;         
     
382.                             break;      
     
383.                  }      
     
384.                 while(dat!=0xf0)      
     
385.                  {        
     
386.                   dat=keydata;        
     
387.                   dat=dat&0xf0;      
     
388.                  }            
     
389.                 }      
     
390.         }      
     
391.    keydata=0xfb;   
     
392.    dat=keydata;   
     
393.    dat=dat&0xf0;   
     
394.     while(dat!=0xf0)     
     
395.          {      
     
396.           delayms(5);      
     
397.           dat=keydata;      
     
398.           dat=dat&0xf0;      
     
399.         while(dat!=0xf0)      
     
400.          {      
     
401.           dat=keydata;      
     
402.         switch(dat)      
     
403.          {        
     
404.           case 0xeb:num=9;         
     
405.                     break;         
     
406.           case 0xdb:num=10;
     
407.                     break;        
     
408.           case 0xbb:num=11;         
     
409.                     break;        
     
410.           case 0x7b:num=12;        
     
411.                     break;      
     
412.          }      
     
413.         while(dat!=0xf0)      
     
414.          {        
     
415.           dat=keydata;        
     
416.           dat=dat&0xf0;      
     
417.          }           
     
418.     }     
     
419.    }      
     
420.   keydata=0xf7;   
     
421.   dat=keydata;   
     
422.   dat=dat&0xf0;   
     
423.   while(dat!=0xf0)     
     
424.    {      
     
425.     delayms(5);      
     
426.     dat=keydata;      
     
427.         dat=dat&0xf0;      
     
428.         while(dat!=0xf0)      
     
429.          {      
     
430.           dat=keydata;      
     
431.         switch(dat)      
     
432.          {        
     
433.           case 0xe7:num=13;         
     
434.                     break;        
     
435.           case 0xd7:num=14;         
     
436.                     break;        
     
437.           case 0xb7:num=15;         
     
438.                     break;        
     
439.           case 0x77:num=16;         
     
440.                     break;      
     
441.           }      
     
442.         while(dat!=0xf0)      
     
443.          {        
     
444.           dat=keydata;        
     
445.           dat=dat&0xf0;        
     
446.          }
     
447.         }   
     
448.    }            
     
449.     switch(num)   
     
450.          {   
     
451.           case 1:write_12864_addr(3,7);     
     
452.                  anjian=0;     
     
453.                          anjian_dis();     
     
454.                          break;   
     
455.           case 2:write_12864_addr(3,7);     
     
456.                  anjian=10;     
     
457.                          anjian_dis();     
     
458.                          break;   
     
459.           case 3:write_12864_addr(3,7);     
     
460.                  anjian=20;     
     
461.                          anjian_dis();     
     
462.                          break;   
     
463.           case 4:write_12864_addr(3,7);     
     
464.                  anjian=30;     
     
465.                          anjian_dis();     
     
466.                          break;   
     
467.           case 5:write_12864_addr(3,7);     
     
468.                  anjian=40;     
     
469.                          anjian_dis();     
     
470.                          break;   
     
471.           case 6:write_12864_addr(3,7);     
     
472.                  anjian=50;     
     
473.                          anjian_dis();     
     
474.                          break;   
     
475.           case 7:write_12864_addr(3,7);     
     
476.                  anjian=60;     
     
477.                          anjian_dis();     
     
478.                          break;   
     
479.           case 8:write_12864_addr(3,7);     
     
480.                  anjian=anjian+1;     
     
481.                          anjian_dis();     
     
482.                          break;   
     
483.           case 9:write_12864_addr(3,7);      
     
484.                  anjian=anjian+2;
     
485.              anjian_dis();     
     
486.                          break;   
     
487.           case 10:write_12864_addr(3,7);     
     
488.                   anjian=anjian+3;     
     
489.                           anjian_dis();         
     
490.                           break;   
     
491.           case 11:write_12864_addr(3,7);         
     
492.                   anjian=anjian+4;     
     
493.                           anjian_dis();     
     
494.                           break;   
     
495.           case 12:write_12864_addr(3,7);         
     
496.                   anjian=anjian+5;     
     
497.                           anjian_dis();     
     
498.                           break;   
     
499.           case 13:write_12864_addr(3,7);         
     
500.                   anjian=anjian+6;     
     
501.                           anjian_dis();     
     
502.                           break;   
     
503.           case 14:write_12864_addr(3,7);         
     
504.                   anjian=anjian+7;     
     
505.                           anjian_dis();      
     
506.                           break;   
     
507.           case 15:write_12864_addr(3,7);     
     
508.                   anjian=anjian+8;   
     
509.                           anjian_dis();     
     
510.                           break;   
     
511.           case 16:write_12864_addr(3,7);     
     
512.                   anjian=anjian+9;     
     
513.                           anjian_dis();      
     
514.                           break;     
     
515.         }   
     
516.    }
     
517. void timer0() interrupt 3
     
518. {   
     
519.   A1=1;  
     
520.   A2=0;   
     
521.   TH1=(65535-100)/256;  
     
522.   TL1=(65535-100)%256;  
     
523.   count++;   
     
524.   if(count>=100)  
     
525.      count=0;   
     
526.   if(count<pwm)  
     
527.     {   
     
528.           ENA=1;  
     
529.          }  
     
530.   else   
     
531.       ENA=0;  
     
532. }
     
533. 
     
534. 
     
535. 
     
536. 
     
537. 
     
538. 
     
539. 
     
540. 
     
541. 
     
542. 
     
543. /***********************************************************
     
544. ******************12864.C文件*******************************
     
545.           12864指令：
     
546. 0x01/将DDRAM填满“20H”，并且设定DDRAM的地址计数器（AC）到“00H”
     
547. 0x02//设定DDRAM的地址计数器（AC）到“00H”，并且将游标移到开头原点位置；这个指令并不改变DDRAM的内容
     
548. 0x04//读写后,AC减一,向左写
     
549. 0x06//读写后,AC加一,向右写
     
550. 0x10//光标向左移动,AC减一
     
551. 0x14//光标向右移动,AC加一
     
552. 0x18//显示向左移动,光标跟着移动
     
553. 0x1c//显示向右移动,光标跟着移动
     
554. 0x0c//整体显示开，游标关，游标位置反白不允许
     
555. 0x0e//整体显示开，游标开，游标位置反白不允许
     
556. 0x0f//整体显示开，游标开，游标位置反白允许
     
557. 0x08//关显示,关光标,关光标闪烁
     
558. 0x30//8位数据端口，基本指令操作
     
559. 0x34//8位数据总线,扩展指令集
     
560. 0x20//4位数据总线,基本指令集
     
561. 0x24//4位数据总线,扩展指令集
     
562. **************************************************************/
     
563. 
     
564. #include<reg51.h>
     
565. #include"12864.h"
     
566. #include"control.h"
     
567. #define lcd_data P0 //定义液晶数据端口
     
568. sbit lcd_PSB=P3^7; //液晶串行数据和并行数据选择端
     
569. sbit lcd_EN=P2^7; //液晶en使能端
     
570. sbit lcd_RS=P2^6;//液晶的rs
     
571. sbit lcd_RW=P2^5; //液晶的rw读写端口
     
572. 
     
573. void delayms_12864(unsigned char xms) //延时函数
     
574. {
     
575.   unsigned char i,j;
     
576.   for(i=0;i<xms;i++)
     
577.   for(j=0;j<110;j++);
     
578. }
     
579. bit check_12864_busy()//检测液晶忙不忙
     
580. {
     
581.   bit result=0;
     
582.   lcd_RS=0;
     
583.   lcd_RW=1;   
     
584.   lcd_EN=1;   
     
585.   delayms_12864(3);   
     
586.   result=(bit)(lcd_data&0x80);  //取出数据端口的最高位   
     
587.   lcd_EN=0;   
     
588.   return result;  
     
589.   }  
     
590. void write_12864_cmd(unsigned char cmd )   //写指令
     
591. {   
     
592.   while(check_12864_busy());    //检测液晶忙不忙   
     
593.   lcd_RS=0;      //rs=0为写命令  
     
594.   lcd_EN=0;  
     
595.   lcd_RW=0;   
     
596.   lcd_data=cmd;    //把指令给数据端口  
     
597.   delayms_12864(1);  
     
598.   lcd_EN=1;   
     
599.   delayms_12864(1);  
     
600.   lcd_EN=0;  
     
601. }   
     
602. void write_12864_data(unsigned char dat) //向液晶写数据  
     
603. {   
     
604.   while(check_12864_busy());    //检测液晶忙不忙   
     
605.   lcd_RS=1;    //rs=1为写数据  
     
606.   lcd_EN=0;  
     
607.   lcd_RW=0;   
     
608.   lcd_data=dat;   //把数据给数据端口  
     
609.   delayms_12864(1);  
     
610.   lcd_EN=1;   
     
611.   delayms_12864(1);  
     
612.   lcd_EN=0;  
     
613. }            
     
614. void lcd_12864_init()    //初始化液晶
     
615. {   
     
616.   lcd_PSB=1;   
     
617.   write_12864_cmd(0x30);  
     
618.   delayms_12864(5);   
     
619.   write_12864_cmd(0x0c);  
     
620.   delayms_12864(5);   
     
621.   write_12864_cmd(0x01);  
     
622.   delayms_12864(5);
     
623.   }
     
624. void write_12864_addr(unsigned char x,unsigned char y)//写液晶的地址
     
625. {
     
626.   unsigned char addr;
     
627.   if(x==0) //如果x=0，地址为液晶第一行
     
628.     {x=0x80;}
     
629.   else if(x==1) //如果x=1，地址为液晶第二行
     
630.     {x=0x90;}
     
631.   else if(x==2) //如果x=2，地址为液晶第三行
     
632.     {x=0x88;}
     
633.   else if(x==3) //如果x=3，地址为液晶第四行
     
634.     {x=0x98;}
     
635.   addr=x+y;
     
636.   write_12864_cmd(addr);
     
637. }
     
638. 
     
639. 
     
640. 
     
641. 
     
642. 
     
643. 
     
644. 
     
645. 
     
646. 
     
647. 
     
648. 
     
649. 
     
650. 
     
651. 
     
652. 
     
653. 
     
654. 
     
655. //ADXL.C 文件
     
656. #include <reg51.H>
     
657. #include <math.h>   //Keil library
     
658. #include <stdio.h>  //Keil library
     
659. #include <intrins.h>
     
660. #include "12864.h"
     
661.   
     
662. #define uchar unsigned char
     
663. #define uint unsigned int
     
664. #define DataPort P1 //LCD1602数据端口
     
665. sbit SCL=P2^0; //IIC时钟引脚定义
     
666. sbit SDA=P2^1; //IIC数据引脚定义
     
667. sbit LED=P2^2;
     
668. #define SlaveAddress 0xA6 //定义器件在IIC总线中的从地址,根据ALT ADDRESS地址引脚不同修改
     
669. //ALT ADDRESS引脚接地时地址为0xA6，接电源时地址为0x3A
     
670. typedef unsigned char BYTE;
     
671. typedef unsigned short WORD;
     
672. 
     
673. BYTE BUF[8];  //接收数据缓存区        
     
674. uchar ge,shi,bai,qian,wan; //显示变量
     
675. int dis_data;  //变量
     
676. 
     
677. void delay(unsigned int k);
     
678. void InitLcd(); //初始化lcd1602
     
679. void Init_ADXL345(void); //初始化ADXL345
     
680. 
     
681. void WriteDataLCM(uchar dataW);
     
682. void WriteCommandLCM(uchar CMD,uchar Attribc);
     
683. void DisplayOneChar(uchar X,uchar Y,uchar DData);         /**/
     
684. void conversion(uint temp_data);
     
685. 
     
686. void Single_Write_ADXL345(uchar REG_Address,uchar REG_data); //单个写入数据
     
687. uchar Single_Read_ADXL345(uchar REG_Address); //单个读取内部寄存器数据
     
688. void Multiple_Read_ADXL345();
     
689. 
     
690. //连续的读取内部寄存器数据
     
691. void Delay5us();
     
692. void Delay5ms();
     
693. void ADXL345_Start();
     
694. void ADXL345_Stop();
     
695. void ADXL345_SendACK(bit ack);
     
696. bit ADXL345_RecvACK();
     
697. void ADXL345_SendByte(BYTE dat);
     
698. BYTE ADXL345_RecvByte();
     
699. 
     
700. void ADXL345_ReadPage();
     
701. void ADXL345_WritePage();
     
702.   float tempz;
     
703.   float tempy;
     
704.   float tempx;
     
705.   uchar tab[]="度";
     
706.   uchar tab1[]="偏转";
     
707.   uchar tab2[]="风力";
     
708.   uchar tab3[]="输入";
     
709. 
     
710. void conversion(uint temp_data)
     
711. {
     
712.   wan=temp_data/10000+0x30;
     
713.    temp_data=temp_data%10000; //取余运算
     
714.   qian=temp_data/1000+0x30;
     
715.    temp_data=temp_data%1000;//取余运算
     
716.   bai=temp_data/100+0x30;
     
717.    temp_data=temp_data%100;//取余运算
     
718.    shi=temp_data/10+0x30;
     
719.    temp_data=temp_data%10; //取余运算
     
720.    ge=temp_data+0x30;
     
721. }
     
722. 
     
723. //void DisplayOneChar(uchar DData)  /**/
     
724. // {
     
725. //  Y&=1;
     
726. //  X&=15;
     
727. //  if(Y)X|=0x40;
     
728. //  X|=0x80;
     
729. //  write_12864_addr(X,0);
     
730. //  write_12864_data(DData);          /*这一段*/
     
731. // }
     
732. 
     
733. /****延时5微秒(STC90C52RC@12M)
     
734. 不同的工作环境,需要调整此函数，
     
735. 注意时钟过快时需要修改,当改用1
     
736. T的MCU时,请调整此延时函数
     
737. ***********/
     
738. void Delay5us()
     
739. {
     
740.    _nop_();
     
741.    _nop_();
     
742.    _nop_();
     
743.    _nop_();
     
744.    _nop_();
     
745.    _nop_();
     
746.    _nop_();
     
747.    _nop_();
     
748.    _nop_();
     
749.    _nop_();
     
750.    _nop_();
     
751.    _nop_();
     
752. }
     
753. /*延时5毫秒(STC90C52RC@12M)不同
     
754. 的工作环境,需要调整此函数当改用
     
755. 1T的MCU时,请调整此延时函数*/
     
756. void Delay5ms()
     
757. {
     
758.    WORD n=560;
     
759.    while(n--);
     
760. }
     
761. /*起始信号*/
     
762. void ADXL345_Start()
     
763. {
     
764.    SDA=1;//拉高数据线
     
765.    SCL=1;//拉高时钟线
     
766.    Delay5us();//延时
     
767.    SDA=0;//产生下降沿
     
768.    Delay5us();//延时
     
769.    SCL=0;//拉低时钟线
     
770. }
     
771. /**停止信号**/
     
772. void ADXL345_Stop()
     
773. {
     
774.   SDA=0;//拉低数据线
     
775.   SCL=1;//拉高时钟线
     
776.   Delay5us();//延时
     
777.   SDA=1;//产生上升沿
     
778.   Delay5us();//延时
     
779. }
     
780. 
     
781. /*发送应答信号
     
782. 入口参数:ack(0:ACK 1:NAK)
     
783. *************************/
     
784. void ADXL345_SendACK(bit ack)
     
785. {
     
786.   SDA=ack;//写应答信号
     
787.   SCL=1;//拉高时钟线
     
788.   Delay5us();//延时
     
789.   SCL=0;//拉低时钟线
     
790.   Delay5us();//延时
     
791. }
     
792. 
     
793. //void ADXL345_SendACK(bit ack)
     
794. // {
     
795. //  SDA=ack; //写应答信号
     
796. //  SCL=1;//拉高时钟线
     
797. //  Delay5us();//延时
     
798. //  SCL=0;//拉低时钟线
     
799. //  Delay5us();//延时
     
800. //  }
     
801. /*接收应答信号*/
     
802. bit ADXL345_RecvACK()
     
803.   {
     
804.    SCL=1; //拉高时钟线
     
805.    Delay5us();//延时?
     
806.    CY=SDA; //读应答信号
     
807.    SCL=0;//拉低时钟线
     
808.    Delay5us(); //延时
     
809.    return CY;
     
810.    }
     
811. 
     
812. /*向IIC总线发送一个字节数据**/
     
813. void ADXL345_SendByte(BYTE dat)
     
814.   {
     
815.     BYTE i;
     
816.      for(i=0;i<8;i++)//8位计数器
     
817.           {
     
818.         dat<<=1;//移出数据的最高位
     
819.                 SDA=CY;//送数据口
     
820.                 SCL=1;//拉高时钟线
     
821.                 Delay5us();//延时
     
822.         SCL=0;//拉低时钟线
     
823.                 Delay5us();//延时
     
824.                 }
     
825. ADXL345_RecvACK();
     
826. }
     
827. 
     
828. /*从IIC总线接收一个字节数据*/
     
829. BYTE ADXL345_RecvByte()
     
830. {
     
831.   BYTE i;
     
832.   BYTE dat=0;
     
833.   SDA=1;//使能内部上拉,准备读取数据,
     
834.   for(i=0;i<8;i++) //8位计数器
     
835.   {
     
836.    dat<<=1;
     
837.    SCL=1;//拉高时钟线
     
838.    Delay5us();//延时
     
839.    dat|=SDA;//读数据
     
840.    SCL=0;//拉低时钟线
     
841.    Delay5us();//延时
     
842.    }
     
843. return dat;
     
844.    }
     
845. 
     
846. /*单字节写入*/
     
847. void Single_Write_ADXL345(uchar REG_Address,uchar REG_data)
     
848. {
     
849.    ADXL345_Start();//起始信号
     
850.    ADXL345_SendByte(SlaveAddress);//发送设备地址+写信号
     
851.    ADXL345_SendByte(REG_Address);//内部寄存器地址，请参考中文pdf22页
     
852.    ADXL345_SendByte(REG_data);//内部寄存器数据，请参考中文pdf22页
     
853.    ADXL345_Stop();//发送停止信号
     
854. }
     
855. 
     
856. /*单字节读取*/
     
857. uchar Single_Read_ADXL345(uchar REG_Address)
     
858. { uchar REG_data;
     
859.     ADXL345_Start(); //起始信号
     
860.     ADXL345_SendByte(SlaveAddress);//发送设备地址+写信号
     
861.     ADXL345_SendByte(REG_Address);//发送存储单元地址，从0开始
     
862.         ADXL345_Start(); //起始信号
     
863.     ADXL345_SendByte(SlaveAddress+1);//发送设备地址+读信号
     
864.     REG_data=ADXL345_RecvByte(); //读出寄存器数据
     
865.         ADXL345_SendACK(1);
     
866.     ADXL345_Stop();//停止信号
     
867.         return REG_data;
     
868.         }
     
869. 
     
870. 
     
871. /*连续读出ADXL345内部加速度数据，地址范围0x32~0x37*/
     
872. void Multiple_read_ADXL345(void)
     
873. {
     
874.   uchar i;
     
875.   ADXL345_Start();//起始信号
     
876.   ADXL345_SendByte(SlaveAddress);//发送设备地址+写信号
     
877.   ADXL345_SendByte(0x32);//发送存储单元地址，从0x32开始
     
878.   ADXL345_Start();//起始信号
     
879.   ADXL345_SendByte(SlaveAddress+1);//发送设备地址+读信号
     
880.   for(i=0;i<6;i++)//连续读取6个地址数据，存储中BUF
     
881.    {
     
882.      BUF[i]=ADXL345_RecvByte();//BUF[0]存储0x32地址中的数据
     
883.      if(i==5)
     
884.            {
     
885.          ADXL345_SendACK(1); //最后一个数据需要回NOACK
     
886.              }
     
887.          else
     
888.          {
     
889.       ADXL345_SendACK(0);//回应ACK
     
890.            }
     
891.           }
     
892.       ADXL345_Stop(); //停止信号
     
893.           Delay5ms();
     
894.          }
     
895. 
     
896. /**初始化ADXL345，根据需要请参考pdf进行修改*/
     
897. void Init_ADXL345()
     
898. {
     
899.    Single_Write_ADXL345(0x31,0x0B); //测量范围,正负16g，13位模式
     
900.    Single_Write_ADXL345(0x2C,0x08);  //速率设定为12.5参考pdf13页
     
901.    Single_Write_ADXL345(0x2D,0x08);//选择电源模式 参考pdf24页
     
902.    Single_Write_ADXL345(0x2E,0x80); //使能DATA_READY中断
     
903.    Single_Write_ADXL345(0x1E,0x00); //X偏移量,根据测试传感器的状态写入pdf29页
     
904.    Single_Write_ADXL345(0x1F,0x00);  //Y偏移量,根据测试传感器的状态写入pdf29页
     
905.    Single_Write_ADXL345(0x20,0x05); //Z偏移量,根据测试传感器的状态写入pdf29页
     
906. }
     
907. /*显示x轴*/
     
908. void display_x()
     
909. {
     
910.   float tempx;          /**/
     
911.   dis_data=(BUF[1]<<8)+BUF[0]; //合成数据
     
912.   if(dis_data<0)
     
913.    {
     
914.      dis_data=-dis_data;
     
915.          write_12864_addr(2,1);
     
916.      write_12864_data('-');//显示正负符号位
     
917.         }
     
918.    else
     
919.     {
     
920.       write_12864_addr(2,1);
     
921.       write_12864_data(' ');//显示空格
     
922.          }
     
923.    tempx=(float)dis_data*3.9;//计算数据和显示,查考ADXL345快速入门第4页
     
924.    conversion(tempx);//转换出显示需要的数据
     
925.    write_12864_addr(2,0);
     
926.    write_12864_data('X');
     
927.    write_12864_data(':');
     
928.    write_12864_addr(2,2);
     
929.    write_12864_data(qian);
     
930.    write_12864_data('.');
     
931.    write_12864_addr(2,3);
     
932.    write_12864_data(bai);
     
933.    write_12864_data(shi);
     
934. //   write_12864_addr(2,3);                /***/
     
935. //   DisplayOneChar(' ');                /**/
     
936.    }
     
937. /*显示y轴*/
     
938. void display_y()
     
939. {
     
940.    float tempy;  /**/
     
941.    dis_data=(BUF[3]<<8)+BUF[2];//合成数据
     
942.    if(dis_data<0)
     
943.      {
     
944.        dis_data=-dis_data;
     
945.            write_12864_addr(2,5);
     
946.        write_12864_data('-');//显示正负符号位
     
947.            }
     
948.         else
     
949.          {
     
950.       write_12864_addr(2,5);
     
951.       write_12864_data(' ');//显示空格
     
952.           }
     
953.    tempy=(float)dis_data*3.9;//计算数据和显示,查考ADXL345快速入门第4页
     
954.    conversion(tempy);//转换出显示需要的数据
     
955.    write_12864_addr(2,4);
     
956.    write_12864_data('Y');//第1行，第0列显示y
     
957.    write_12864_data(':');
     
958.    write_12864_addr(2,6);
     
959.    write_12864_data(qian);
     
960.    write_12864_data('.');
     
961.    write_12864_addr(2,7);
     
962.    write_12864_data(bai);
     
963.    write_12864_data(shi);
     
964. //   write_12864_addr(2,7);/**/
     
965. //   DisplayOneChar(' ');        /**/
     
966.   }
     
967. /*显示z轴*/
     
968. void display_z()
     
969. {   
     
970. //  float temp; /**/
     
971.   dis_data=(BUF[5]<<8)+BUF[4];//合成数据     
     
972.    if(dis_data<0)
     
973.   {   
     
974.   dis_data=-dis_data;
     
975.   write_12864_addr(3,1);
     
976.   write_12864_data('-'); //显示负符号位
     
977.   }
     
978.    else   
     
979.     {  
     
980.           write_12864_addr(3,1);
     
981.           write_12864_data(' ');  //显示空格  
     
982. 
     
983.    tempz=(float)dis_data*3.9;//计算数据和显示,查考ADXL345快速入门第4页
     
984.    conversion(tempz); //转换出显示需要的数据
     
985.    write_12864_addr(3,0);
     
986.    write_12864_data('Z');//第0行，第10列?显示Z
     
987.    write_12864_data(':');
     
988.    write_12864_addr(3,2);
     
989.    write_12864_data(qian);
     
990.    write_12864_data('.');
     
991.    write_12864_addr(3,3);
     
992.    write_12864_data(bai);
     
993.    write_12864_data(shi);
     
994. //   write_12864_addr(3,4);         /**/
     
995. //   DisplayOneChar(' ');        /**/
     
996.    }
     
997.    }
     
998. //void adxl()           /*这一段*/
     
999. // {
     
1000. //   uchar devid;
      
1001. //   uchar i,j;
      
1002. //   float w;
      
1003. //   delay(500);
      
1004. //   Init_ADXL345();//初始化ADXL345
      
1005. //   devid=Single_Read_ADXL345(0X00);
      
1006. //    } /*这一段*/
      
1007. void jiaodu()
      
1008. {
      
1009.   uchar i,j,k;
      
1010.   float w;
      
1011.   w=(180*atan(tempz/tempx))/3.14;
      
1012.   if(w>=41&&w<=49)
      
1013.     {
      
1014.           LED=0;
      
1015.          }
      
1016.   else
      
1017.    LED=1;
      
1018.    conversion(w);
      
1019.    write_12864_addr(1,4);
      
1020.     {
      
1021.          for(j=0;tab1[j]!='\0';j++)
      
1022.          write_12864_data(tab1[j]);
      
1023.          }
      
1024.     write_12864_addr(1,6);
      
1025.         write_12864_data(shi);
      
1026.         write_12864_data(ge);
      
1027.         write_12864_addr(1,7);
      
1028.          {
      
1029.           for(i=0;tab[i]!='\0';i++)
      
1030.           write_12864_data(tab[i]);
      
1031.          }
      
1032.         write_12864_addr(3,4);
      
1033.          {
      
1034.           for(k=0;tab2[k]!='\0';k++)
      
1035.           write_12864_data(tab2[k]);
      
1036.           }
      
1037.         write_12864_addr(1,0);
      
1038.          {
      
1039.           for(k=0;tab3[k]!='\0';k++)
      
1040.           write_12864_data(tab3[k]);
      
1041.           }
      
1042.          }
      
1043. 
      
1044. void adxl345()
      
1045. {
      
1046.    Multiple_Read_ADXL345();//连续读出数据，存储在BUF中
      
1047.    display_x();//---------显示X轴
      
1048.    display_y();//---------显示Y轴
      
1049.    display_z();//---------显示Z轴
      
1050. //   delay(200); /**/
      
1051.    jiaodu();
      
1052.    }
      
1053. 
      

复制代码

有仿真吗？

这个是电赛的程序？