TI

【TI 技术资料分享】重力加速度传感器实现计步器程序

2019-07-30 18:01发布

站内问答 / TI MCU
5889 0 1021
1ADXL重力加速度传感器实现计步器程序(利用MSP430F135实现) 1ADXL重力加速度传感器实现计步器程序(利用MSP430F135实现).zip (116.54 KB, 下载次数: 15) 2015-3-9 21:24 上传 点击文件名下载附件

  2. //存储器没有文件系统，一次采集，一次上载

  4. #include "delay.h"
  5. #include "Key.h"
  6. #include  <msp430x13x.h>
  7. #include <string.h>
  8. #include <math.h>
  9. #include <stdio.h>
  10. #include"ADC12.h"
  11. #include "hzlib.h"
  12. #include "LCD.h"
  13. #include "SD2608.h"

  15. #define MEM_IN 0x02                        //P3.1
  16. #define MEM_OUT 0x04                       //P3.2
  17. #define SCLK 0x08                          //P3.3
  18. #define ATRDY 0x40                         //AT45DB161 RDY/BUSY          P2.6
  19. #define ATCS 0x80                          //AT45DB161 AT/CS             P2.7
  20. #define TIME_MS 10000                        //采样频率为100



  24. #define X_CHANNEL 0
  25. #define Y_CHANNEL 1
  26. #define Z_CHANNEL 2
  27. //#define TIMEWINDOW_MIN 8                //时间窗，×0.02s＝0.2s
  28. //#define TIMEWINDOW_MAX 30               //时间窗，×0.02s＝0.8s
  29. #define REGULATION      8              //认为找到稳定规律所需要的步数


  32. unsigned char       itemp,jtemp,temp;               
  33. unsigned char       TIMEWINDOW_MIN =11;        //时间窗，×0.02s＝0.2
  34. unsigned char       TIMEWINDOW_MAX =30        ;       //时间窗，×0.02s＝0.8s

  36. unsigned int  Adresult;               
  37. unsigned char _bad_flag[3];                                                                                                                                                       
  38. unsigned char  sampling_counter;                                                               
  39. unsigned int _adresult[3];                                                                       
  40. unsigned int _max[3]={0,0,0};
  41. unsigned int _min[3]={5000,5000,5000};
  42. unsigned int _dc[3]={500,500,500};
  43. unsigned int _vpp[3]={30,30,30};       
  44. unsigned int  _precision[3]={5,5,5};       
  45. unsigned int _old_fixed[3];
  46. unsigned int _new_fixed[3];
  47. unsigned long int STEPS;       
  48. unsigned long int STEPS_Temp;       
  49. unsigned  int _array0[3]={1,1,1};
  50. unsigned  int _array1[3]={1,1,1};
  51. unsigned  int _array2[3]={0,0,0};
  52. unsigned  int _array3[3]={0,0,0};
  53. unsigned  int _array4[3]={0,0,0};
  54. unsigned  int  ADXYZ[3] ;


  57. unsigned long int totalxyz[3];
  58. unsigned int averagexyz[3];
  59. unsigned char avxyz;
  60. unsigned char counter;
  61. unsigned char counterx=0;
  62. unsigned char countery=0;
  63. unsigned char counterz=0;


  66. unsigned char Interval=0;                //记录时间间隔数
  67. unsigned char TempSteps=0;                //记步缓存
  68. unsigned char InvalidSteps=0;        //无效步缓存
  69. unsigned char ReReg=1;                       
  70.                                                                                
  71.                                                                                 //        1-已经开始，但是还没有找到规律
  72.                                                                                 //        0-已经找到规律
  73. unsigned char high_or_low=0,k=0;
  74. unsigned char recieve;
  75. unsigned char date[7];
  76. unsigned char wdata[7]={0,0,128,0,1,1,0};








  85. void fnClkInit(void)
  86. {
  87.   unsigned int a;
  88.   WDTCTL = WDTPW +WDTHOLD;                                //关闭看门狗
  89.    BCSCTL1|=XTS;                                           //XT1口为高频  XTS=1,ACLK = LFXT1
  90.   do
  91.     {
  92.      IFG1&=~OFIFG;                                        //清除振荡器失效标志
  93.      for (a=0xFF;a>0;a--);                                //延时 等待XT1口起振
  94.      }
  95.    while ((IFG1&OFIFG)!=0);                                //判断XT1口是否起振
  96.          BCSCTL2 |= SELM_3;                          //选择LFXT1CLK为MCLK时钟源
  97.          BCSCTL1 |= XT2OFF+DIVA0+DIVA1;                   //禁止XT2口 ACLK 8分频
  98. }  
  99.                     
  100. /*******************定时器初始化定时5MS*******************/
  101. void TimerBInit(void)
  102. {
  103.        TBCTL   = TBSSEL_1 + TBCLR ;               //ACLK为定时器时钟   
  104.        TBCCTL0 = CCIE;                                      //开定时器中断
  105.        TBCCR0  = TIME_MS;                                      //5MS
  106.        //TBCTL  |= MC0;                                       //增计数模式
  107. }



  111. void main(void)
  112. {
  113.    fnClkInit();
  114.    TimerBInit();
  115.    //usart_Init();
  116.    Init_ADC();
  117.    Init_keyPort();
  118.    vdLCD_Init();
  119.    vdDisp_Main();
  120.    clock();
  121.      _EINT();
  122. while(1)
  123.    {
  124.     Iskey ();
  125.      vdDisp_bushu(STEPS);
  126.    }
  127. }


  130. #pragma vector=TIMERB0_VECTOR
  131. __interrupt void Timer_B (void)
  132. {
  133.    ADC12CTL0 &= ~ENC;

  135.   if(recieve==0x04)
  136.    {
  137.      //----------------------------------------------ADC采样----------------------//
  138.        ADXYZ[0] =ADC12MEM0;//AX
  139.        ADXYZ[1]=ADC12MEM1;//AY
  140.        ADXYZ[2]=ADC12MEM2;//AZ
  141.        //----------------------------------------------开机求平均值判断放置位置----------------------//
  142.        if(avxyz==0)
  143.        {  
  144.            counter=counter+1;
  145.            totalxyz[0]=totalxyz[0]+ADXYZ[0];
  146.            totalxyz[1]=totalxyz[1]+ADXYZ[1];
  147.            totalxyz[2]=totalxyz[2]+ADXYZ[2];
  148.            if(counter>=40)
  149.            {
  150.               counter=0;
  151.               counterx=0;
  152.               countery=0;
  153.               counterz=0;
  154.               averagexyz[0]= (int)(totalxyz[0]/40);
  155.               averagexyz[1]= (int)(totalxyz[1]/40);
  156.               averagexyz[2]= (int)(totalxyz[2]/40);
  157.               totalxyz[0]=0;
  158.               totalxyz[1]=0;
  159.               totalxyz[2]=0;
  160.               avxyz=1;
  161.       //----------------------------------------------x方向为垂直位置----------------------//
  162.               if (( averagexyz[0]>= averagexyz[1])&&( averagexyz[0]>= averagexyz[2])&& (averagexyz[0]>3500))
  163.               {
  164.                 counterx=1;
  165.                 countery=0;
  166.                 counterz=0;
  167.               }
  168.               else if (( averagexyz[0]<= averagexyz[1])&&( averagexyz[0]<= averagexyz[2])&& (averagexyz[0]<1800))
  169.               {
  170.                 counterx=1;
  171.                 countery=0;
  172.                 counterz=0;
  173.               }
  174.                //----------------------------------------------y方向为垂直位置----------------------//
  175.              else if (( averagexyz[1]>= averagexyz[0])&&( averagexyz[1]>= averagexyz[2])&& (averagexyz[1]>3500))
  176.               {
  177.                 counterx=0;
  178.                 countery=1;
  179.                 counterz=0;
  180.               }
  181.               else if(( averagexyz[1]<= averagexyz[0])&&( averagexyz[1]<= averagexyz[2])&& (averagexyz[1]<1800))
  182.               {
  183.                 counterx=0;
  184.                 countery=1;
  185.                 counterz=0;
  186.               }
  187.                //----------------------------------------------z方向为垂直位置----------------------//
  188.               else if (( averagexyz[2]>= averagexyz[0])&&( averagexyz[2]>= averagexyz[1])&& (averagexyz[2]>3500))
  189.               {
  190.                 counterx=0;
  191.                 countery=0;
  192.                 counterz=1;
  193.               }
  194.               else if (( averagexyz[2]<= averagexyz[0])&&( averagexyz[2]<= averagexyz[1])&& (averagexyz[2]<1800))
  195.               {
  196.                 counterx=0;
  197.                 countery=0;
  198.                 counterz=1;
  199.               }
  200.               //----------------------------------------------未能确定方向重现找----------------------//
  201.               else
  202.               {
  203.                 avxyz=0;
  204.               }
  205.            }
  206.            
  207.        }
  208.         //----------------------------------------------加速度滤波----------------------//
  209.        if(avxyz==1)
  210.        {
  211.                 for(jtemp=X_CHANNEL;jtemp<=Z_CHANNEL;jtemp++)
  212.                 {
  213.                         _array4[jtemp]=_array3[jtemp];
  214.                         _array3[jtemp]=_array2[jtemp];
  215.                         _array2[jtemp]=_array1[jtemp];
  216.                         _array1[jtemp]=_array0[jtemp];
  217.                        
  218.                        _array0[jtemp]= ADXYZ[jtemp];
  219.                        _adresult[jtemp]=_array0[jtemp]+_array1[jtemp]+_array2[jtemp]+_array3[jtemp]+_array4[jtemp];
  220.                        _adresult[jtemp]=_adresult[jtemp]/5;
  221.                
  222.                         if (_adresult[jtemp]>_max[jtemp])               {_max[jtemp]=_adresult[jtemp];}
  223.                         if (_adresult[jtemp]<_min[jtemp])               {_min[jtemp]=_adresult[jtemp];}
  224.                 }
  225.                
  226.               sampling_counter=sampling_counter+1;
  227.         Interval=Interval+1;
  228.        
  229.                 //----------------------------------计算动态门限和动态精度-----------------------//
  230.         if (sampling_counter==50)
  231.           {               
  232.           sampling_counter=0;
  233.                                
  234.           for(jtemp=X_CHANNEL;jtemp<=Z_CHANNEL;jtemp++)
  235.                 {
  236.                 _vpp[jtemp]=_max[jtemp]-_min[jtemp];
  237.                                    _dc[jtemp]=_min[jtemp]+_vpp[jtemp]/2;
  238.                                _max[jtemp]=0;
  239.                                    _min[jtemp]=5000;
  240.                                 _bad_flag[jtemp]=0;

  242.                                 if (_vpp[jtemp]>=1000)
  243.                                      {
  244.                                         TIMEWINDOW_MIN =20;
  245.                                         TIMEWINDOW_MAX =60;
  246.                                         _precision[jtemp]=40;
  247.                                       }
  248.                                     else if ((_vpp[jtemp]>=400)&& (_vpp[jtemp]<1000))            
  249.                                       {
  250.                                         TIMEWINDOW_MIN =25;
  251.                                         TIMEWINDOW_MAX =70;
  252.                                         _precision[jtemp]=20;
  253.                                        }
  254.                                   else if ((_vpp[jtemp]>=200) && (_vpp[jtemp]<400))  
  255.                                      {
  256.                                        TIMEWINDOW_MIN =35;
  257.                                        TIMEWINDOW_MAX =80;
  258.                                         _precision[jtemp]=10;
  259.                                      }  
  260.                        
  261.                                 else
  262.                                    {
  263.                                        _precision[jtemp]=2;
  264.                                  _bad_flag[jtemp]=1;
  265.                                      }

  267.                         }
  268.               }
  269.                
  270.                 //--------------------------线性移位寄存器--------------------------------------//

  272.                 for(jtemp=X_CHANNEL;jtemp<=Z_CHANNEL;jtemp++)
  273.                 {
  274.                         _old_fixed[jtemp]=_new_fixed[jtemp];

  276.                    if (_adresult[jtemp]>=_new_fixed[jtemp])                        
  277.                       {   
  278.                          if((_adresult[jtemp]-_new_fixed[jtemp])>=_precision[jtemp])                  
  279.                         _new_fixed[jtemp]=_adresult[jtemp];
  280.                       }
  281.                   if (_adresult[jtemp]<_new_fixed[jtemp])
  282.                              {   
  283.                            if((_new_fixed[jtemp]-_adresult[jtemp])>=_precision[jtemp])                  
  284.                         _new_fixed[jtemp]=_adresult[jtemp];
  285.                       }
  286.                 }

  288.                 //------------------------- 动态门限判决 ----------------------------------
  289.       
  290.                 if(counterx==1)
  291.                 {
  292.                   if ((_old_fixed[X_CHANNEL]>=_dc[X_CHANNEL])&&(_new_fixed[X_CHANNEL]<_dc[X_CHANNEL])&&(_bad_flag[X_CHANNEL]==0))        
  293.                    {
  294.                                    if((Interval>=TIMEWINDOW_MIN)&&(Interval<=TIMEWINDOW_MAX))        //如果时间间隔在有效的时间窗内
  295.                                         {
  296.                                           if(ReReg==1)                                        //如果还没有找到规律
  297.                                            {            
  298.                                                 TempSteps++;                                        //记步缓存加1
  299.                                               if(TempSteps>=REGULATION)                               //如果记步缓存达到所要求的规律数
  300.                                              {
  301.                                                   ReReg=0;                                //已经找到规律
  302.                                                   STEPS=STEPS+TempSteps;        //更新显示
  303.                                                   TempSteps=0;
  304.                                                }
  305.                                               Interval=0;
  306.                                             }
  307.                                          else if(ReReg==0)                                //如果已经找到规律，直接更新显示
  308.                                           {
  309.                                               STEPS++;
  310.                                               TempSteps=0;
  311.                                               Interval=0;
  312.                                             }
  313.                                        }  
  314.                
  315.                                    else if(Interval>TIMEWINDOW_MAX)        //如果时间间隔大于时间窗上限，记步已经间断，重新寻找规律
  316.                                    {
  317.                                          
  318.                                             InvalidSteps=0;       
  319.                                             ReReg=1;
  320.                                             TempSteps=1;
  321.                                             Interval=0;
  322.                                             
  323.                                             
  324.                        
  325.                                           }
  326.                                      
  327.                                
  328.                        }
  329.                 }
  330.         
  331.         if(countery==1)
  332.         {
  333.           if ((_old_fixed[Y_CHANNEL]>=_dc[Y_CHANNEL])&&(_new_fixed[Y_CHANNEL]<_dc[Y_CHANNEL])&&(_bad_flag[Y_CHANNEL]==0))        
  334.               {
  335.                
  336.                        if((Interval>=TIMEWINDOW_MIN)&&(Interval<=TIMEWINDOW_MAX))        //如果时间间隔在有效的时间窗内
  337.                                         {
  338.                                           if(ReReg==1)                                        //如果还没有找到规律
  339.                                            {            
  340.                                                 TempSteps++;                                        //记步缓存加1
  341.                                               if(TempSteps>=REGULATION)                               //如果记步缓存达到所要求的规律数
  342.                                              {
  343.                                                   ReReg=0;                                //已经找到规律
  344.                                                   STEPS=STEPS+TempSteps;        //更新显示
  345.                                                   TempSteps=0;
  346.                                                }
  347.                                               Interval=0;
  348.                                             }
  349.                                          else if(ReReg==0)                                //如果已经找到规律，直接更新显示
  350.                                           {
  351.                                               STEPS++;
  352.                                               TempSteps=0;
  353.                                               Interval=0;
  354.                                             }
  355.                                        }  
  356.                
  357.                                    else if(Interval>TIMEWINDOW_MAX)        //如果时间间隔大于时间窗上限，记步已经间断，重新寻找规律
  358.                                    {
  359.                                             InvalidSteps=0;       
  360.                                             ReReg=1;
  361.                                             TempSteps=1;
  362.                                             Interval=0;
  363.                                             
  364.                        
  365.                                       }
  366.                                      
  367.                                
  368.                         }
  369.                 }
  370.         if(counterz==1)
  371.         {
  372.           if ((_old_fixed[Z_CHANNEL]>=_dc[Z_CHANNEL])&&(_new_fixed[Z_CHANNEL]<_dc[Z_CHANNEL])&&(_bad_flag[Z_CHANNEL]==0))        
  373.                {
  374.                        
  375.                                    if((Interval>=TIMEWINDOW_MIN)&&(Interval<=TIMEWINDOW_MAX))        //如果时间间隔在有效的时间窗内
  376.                                         {
  377.                                           if(ReReg==1)                                        //如果还没有找到规律
  378.                                            {            
  379.                                                 TempSteps++;                                        //记步缓存加1
  380.                                               if(TempSteps>=REGULATION)                               //如果记步缓存达到所要求的规律数
  381.                                              {
  382.                                                   ReReg=0;                                //已经找到规律
  383.                                                   STEPS=STEPS+TempSteps;        //更新显示
  384.                                                   TempSteps=0;
  385.                                                }
  386.                                               Interval=0;
  387.                                             }
  388.                                          else if(ReReg==0)                                //如果已经找到规律，直接更新显示
  389.                                           {
  390.                                               STEPS++;
  391.                                               TempSteps=0;
  392.                                               Interval=0;
  393.                                             }
  394.                                        }  
  395.                
  396.                                    else if(Interval>TIMEWINDOW_MAX)        //如果时间间隔大于时间窗上限，记步已经间断，重新寻找规律
  397.                                       {
  398.                                          
  399.                                             InvalidSteps=0;       
  400.                                             ReReg=1;
  401.                                             TempSteps=1;
  402.                                             Interval=0;
  403.                                            
  404.                        
  405.                                           }
  406.                                             
  407.                        
  408.                     }
  409.           }
  410.         if(Interval>=250)
  411.         {
  412.           avxyz=0;
  413.           Interval=0;
  414.         }
  415.    
  416.        }
  417.       
  418.    }

  420.     ADC12CTL0 |=ENC;  //可能需要，也可能不需要
  421.     ADC12CTL0 |= ADC12SC;
  422.    }
复制代码

发送
 看不清?
0条回答

一周热门 更多>

相关文章