设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 帆板运动（adxl3+有字库1268+51单片机+矩阵键盘）源程序
返回列表 发新帖
查看: 2221|回复: 2
打印 上一主题 下一主题
收起左侧

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

[复制链接]
跳转到指定楼层
楼主
ID:220429 发表于 2017-7-19 15:15 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
帆板运动（adxl3+有字库1268+51单片机+矩阵键盘）

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


  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.   /*********************************






  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







  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






  74. //ADXL.H文件
  75. #ifndef __ADXL_h_  
  76. #define __ADXL_h_

  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();

  87. #endif






  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.          }

  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. }










  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. **************************************************************/

  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读写端口

  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. }

















  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;

  673. BYTE BUF[8];  //接收数据缓存区        
  674. uchar ge,shi,bai,qian,wan; //显示变量
  675. int dis_data;  //变量

  677. void delay(unsigned int k);
  678. void InitLcd(); //初始化lcd1602
  679. void Init_ADXL345(void); //初始化ADXL345

  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);

  686. void Single_Write_ADXL345(uchar REG_Address,uchar REG_data); //单个写入数据
  687. uchar Single_Read_ADXL345(uchar REG_Address); //单个读取内部寄存器数据
  688. void Multiple_Read_ADXL345();

  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();

  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[]="输入";

  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. }

  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. // }

  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. }

  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. }

  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.    }

  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. }

  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.    }

  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. }

  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.         }


  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.          }

  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(' ');  //显示空格  

  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.          }

  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.    }

复制代码


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:221046 发表于 2017-7-20 14:26 | 只看该作者
有仿真吗？
回复

使用道具 举报

板凳
ID:221458 发表于 2017-7-23 21:44 | 只看该作者
这个是电赛的程序？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表