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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › STM32双定时器TIM2和TIM4+8个HC-SR04超声波源程序
返回列表 发新帖
查看: 2096|回复: 0
收起左侧

STM32双定时器TIM2和TIM4+8个HC-SR04超声波源程序

[复制链接]
ID:259935 发表于 2020-2-25 23:31 | 显示全部楼层 |阅读模式
单片机源程序如下:
  1. #include "timer.h"
  2. TIM_ICInitTypeDef  TIM2_ICInitStructure;
  3. TIM_ICInitTypeDef  TIM4_ICInitStructure;
  4. void TIM2_Cap_Init(u16 arr,u16 psc)
  5. {
  6.         GPIO_InitTypeDef GPIO_InitStructure;
  7.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  8.   NVIC_InitTypeDef NVIC_InitStructure;
  9.         
  10.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);        //使能TIM2时钟
  11.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);  //使能GPIOA时钟
  12.         
  13.         //TIM2的2个通道
  14.         GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
  15.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0 输入  下拉
  16.         GPIO_Init(GPIOA, &GPIO_InitStructure);
  17.         GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
  18.         
  19.         
  20.         TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值
  21.         TIM_TimeBaseStructure.TIM_Prescaler =psc;         //预分频器   
  22.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
  23.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
  24.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
  25.         
  26.         //初始化TIM2通道1输入捕获参数
  27.         TIM2_ICInitStructure.TIM_Channel = TIM_Channel_1; //CC1S=01         选择输入端 IC1映射到TI1上
  28.           TIM2_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  29.           TIM2_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  30.           TIM2_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  31.           TIM2_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  32.           TIM_ICInit(TIM2, &TIM2_ICInitStructure);
  33.         //初始化TIM2通道1输入捕获参数
  34.         TIM2_ICInitStructure.TIM_Channel = TIM_Channel_2; //CC1S=01         选择输入端 IC1映射到TI1上
  35.           TIM2_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  36.           TIM2_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  37.           TIM2_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  38.           TIM2_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  39.           TIM_ICInit(TIM2, &TIM2_ICInitStructure);
  40.                
  41.                         TIM2_ICInitStructure.TIM_Channel = TIM_Channel_3; //CC1S=01         选择输入端 IC1映射到TI1上
  42.           TIM2_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  43.           TIM2_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  44.           TIM2_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  45.           TIM2_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  46.           TIM_ICInit(TIM2, &TIM2_ICInitStructure);
  47.                
  48.                         TIM2_ICInitStructure.TIM_Channel = TIM_Channel_4; //CC1S=01         选择输入端 IC1映射到TI1上
  49.           TIM2_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  50.           TIM2_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  51.           TIM2_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  52.           TIM2_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  53.           TIM_ICInit(TIM2, &TIM2_ICInitStructure);
  54.                

  56.         
  57.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;  //TIM2中断
  58.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级2级
  59.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  //从优先级0级
  60.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
  61.         NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
  62.         
  63.         TIM_ITConfig(TIM2,TIM_IT_Update|TIM_IT_CC1|TIM_IT_CC2|TIM_IT_CC3|TIM_IT_CC4,ENABLE);//允许更新中断 ,允许CC2IE捕获中断
  64.         
  65.         TIM_Cmd(TIM2,ENABLE );
  66. }


  69. //*****************************************************************
  70. //************************************************************




  75. void TIM4_Cap_Init(u16 arr,u16 psc)
  76. {
  77.         GPIO_InitTypeDef GPIO_InitStructure;
  78.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  79.   NVIC_InitTypeDef NVIC_InitStructure;
  80.         
  81.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);        //使能TIM4时钟
  82.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  //使能GPIOA时钟
  83.         
  84.         //TIM4的2个通道
  85.         GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9;
  86.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0 输入  下拉
  87.         GPIO_Init(GPIOB, &GPIO_InitStructure);
  88.         GPIO_ResetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9);
  89.         
  90.         

  92.         TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值
  93.         TIM_TimeBaseStructure.TIM_Prescaler =psc;         //预分频器   
  94.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
  95.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
  96.         TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
  97.         
  98.         //初始化TIM4通道1输入捕获参数
  99.         TIM4_ICInitStructure.TIM_Channel = TIM_Channel_1; //CC1S=01         选择输入端 IC1映射到TI1上
  100.           TIM4_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  101.           TIM4_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  102.           TIM4_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  103.           TIM4_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  104.           TIM_ICInit(TIM4, &TIM4_ICInitStructure);

  106.         TIM4_ICInitStructure.TIM_Channel = TIM_Channel_2; //CC1S=01         选择输入端 IC1映射到TI1上
  107.           TIM4_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  108.           TIM4_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  109.           TIM4_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  110.           TIM4_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  111.           TIM_ICInit(TIM4, &TIM4_ICInitStructure);
  112.                
  113.                         TIM4_ICInitStructure.TIM_Channel = TIM_Channel_3; //CC1S=01         选择输入端 IC1映射到TI1上
  114.           TIM4_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  115.           TIM4_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  116.           TIM4_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  117.           TIM4_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  118.           TIM_ICInit(TIM4, &TIM4_ICInitStructure);
  119.                
  120.                         TIM4_ICInitStructure.TIM_Channel = TIM_Channel_4; //CC1S=01         选择输入端 IC1映射到TI1上
  121.           TIM4_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
  122.           TIM4_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上
  123.           TIM4_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
  124.           TIM4_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波
  125.           TIM_ICInit(TIM4, &TIM4_ICInitStructure);

  127.         
  128.         NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;  //TIM4中断
  129.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级2级
  130.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  //从优先级0级
  131.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
  132.         NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
  133.         
  134.         TIM_ITConfig(TIM4,TIM_IT_Update|TIM_IT_CC1|TIM_IT_CC2|TIM_IT_CC3|TIM_IT_CC4,ENABLE);//允许更新中断 ,允许CC2IE捕获中断
  135.         
  136.         TIM_Cmd(TIM4,ENABLE );
  137. }


  140. u8  TIM2CH1_CAPTURE_STA=0;        //输入捕获状态                                                   
  141. u16        TIM2CH1_CAPTURE_VAL;        //输入捕获值
  142. u8  TIM2CH2_CAPTURE_STA=0;        //输入捕获状态        
  143. u16        TIM2CH2_CAPTURE_VAL;        //输入捕获值
  144. u16        TIM2CH3_CAPTURE_VAL;        //输入捕获值
  145. u8  TIM2CH3_CAPTURE_STA=0;        //输入捕获状态                                                   
  146. u16        TIM2CH4_CAPTURE_VAL;        //输入捕获值                                                      
  147. u8  TIM2CH4_CAPTURE_STA=0;        //输入捕获状态        

  149. u8  TIM4CH1_CAPTURE_STA=0;        //输入捕获状态                                                   
  150. u16        TIM4CH1_CAPTURE_VAL;        //输入捕获值
  151. u8  TIM4CH2_CAPTURE_STA=0;        //输入捕获状态        
  152. u16        TIM4CH2_CAPTURE_VAL;        //输入捕获值
  153. u16        TIM4CH3_CAPTURE_VAL;        //输入捕获值
  154. u8  TIM4CH3_CAPTURE_STA=0;        //输入捕获状态                                                   
  155. u16        TIM4CH4_CAPTURE_VAL;        //输入捕获值                                                      
  156. u8  TIM4CH4_CAPTURE_STA=0;        //输入捕获状态        

  158. extern u32 distan1,distan2;
  159. extern u32 distan3,distan4;
  160. extern u32 distan5,distan6;
  161. extern u32 distan7,distan8;
  162. void TIM2_IRQHandler(void)
  163. {
  164.         if((TIM2CH1_CAPTURE_STA&0X80)==0)//还未成功捕获        
  165.         {         
  166.                 if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)         
  167.                 {            
  168.                         if(TIM2CH1_CAPTURE_STA&0X40)//已经捕获到高电平了
  169.                         {
  170.                                 if((TIM2CH1_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  171.                                 {
  172.                                         TIM2CH1_CAPTURE_STA|=0X80;//标记成功捕获了一次
  173.                                         TIM2CH1_CAPTURE_VAL=0XFFFF;
  174.                                 }else TIM2CH1_CAPTURE_STA++;
  175.                         }         
  176.                 }
  177.         if (TIM_GetITStatus(TIM2, TIM_IT_CC1) != RESET)//捕获1发生捕获事件
  178.                 {        
  179.                         if(TIM2CH1_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  180.                         {                                 
  181.                                         TIM2CH1_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  182.                                         TIM2CH1_CAPTURE_VAL=TIM_GetCapture1(TIM2);
  183.                                 

  185.                                         distan1=TIM2CH1_CAPTURE_STA&0X3F;
  186.                                         distan1*=65536;//溢出时间总和
  187.                                         distan1+=TIM2CH1_CAPTURE_VAL;//得到总的高电平时间
  188.                                         distan1=340*distan1/2/10000;

  190.                                 
  191.                                         TIM2CH1_CAPTURE_STA=0;
  192.                                    TIM_OC1PolarityConfig(TIM2,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  193.                         }else                                                                  //还未开始,第一次捕获上升沿
  194.                         {
  195.                                 TIM2CH1_CAPTURE_STA=0;                        //清空
  196.                                 TIM2CH1_CAPTURE_VAL=0;
  197.                                  TIM_SetCounter(TIM2,0);
  198.                                 TIM2CH1_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  199.                                    TIM_OC1PolarityConfig(TIM2,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  200.                         }                    
  201.                 }                                                                                    
  202.          }
  203.         
  204.         if((TIM2CH2_CAPTURE_STA&0X80)==0)//还未成功捕获        
  205.         {         
  206.                 if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  207.                  
  208.                 {            
  209.                         if(TIM2CH2_CAPTURE_STA&0X40)//已经捕获到高电平了
  210.                         {
  211.                                 if((TIM2CH2_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  212.                                 {
  213.                                         TIM2CH2_CAPTURE_STA|=0X80;//标记成功捕获了一次
  214.                                         TIM2CH2_CAPTURE_VAL=0XFFFF;
  215.                                 }else TIM2CH2_CAPTURE_STA++;
  216.                         }         
  217.                 }
  218.         if (TIM_GetITStatus(TIM2, TIM_IT_CC2) != RESET)//捕获1发生捕获事件
  219.                 {        
  220.                         if(TIM2CH2_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  221.                         {                                 
  222.                                         TIM2CH2_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  223.                                         TIM2CH2_CAPTURE_VAL=TIM_GetCapture2(TIM2);
  224.                                         distan2=TIM2CH2_CAPTURE_STA&0X3F;
  225.                                         distan2*=65536;//溢出时间总和
  226.                                         distan2+=TIM2CH2_CAPTURE_VAL;//得到总的高电平时间
  227.                                         distan2=340*distan2/2/10000;

  229.                                 
  230.                                         TIM2CH2_CAPTURE_STA=0;
  231.                                    TIM_OC2PolarityConfig(TIM2,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  232.                         }else                                                                  //还未开始,第一次捕获上升沿
  233.                         {
  234.                                 TIM2CH2_CAPTURE_STA=0;                        //清空
  235.                                 TIM2CH2_CAPTURE_VAL=0;
  236.                                  TIM_SetCounter(TIM2,0);
  237.                                 TIM2CH2_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  238.                                    TIM_OC2PolarityConfig(TIM2,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  239.                         }                    
  240.                 }                                                                                    
  241.          }
  242.         
  243.         
  244.         if((TIM2CH3_CAPTURE_STA&0X80)==0)//还未成功捕获        
  245.         {         
  246.                 if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)         
  247.                 {            
  248.                         if(TIM2CH3_CAPTURE_STA&0X40)//已经捕获到高电平了
  249.                         {
  250.                                 if((TIM2CH3_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  251.                                 {
  252.                                         TIM2CH3_CAPTURE_STA|=0X80;//标记成功捕获了一次
  253.                                         TIM2CH3_CAPTURE_VAL=0XFFFF;
  254.                                 }else TIM2CH3_CAPTURE_STA++;
  255.                         }         
  256.                 }
  257.         if (TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET)//捕获1发生捕获事件
  258.                 {        
  259.                         if(TIM2CH3_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  260.                         {                                 
  261.                                         TIM2CH3_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  262.                                         TIM2CH3_CAPTURE_VAL=TIM_GetCapture3(TIM2);
  263.                                 

  265.                                         distan3=TIM2CH3_CAPTURE_STA&0X3F;
  266.                                         distan3*=65536;//溢出时间总和
  267.                                         distan3+=TIM2CH3_CAPTURE_VAL;//得到总的高电平时间
  268.                                         distan3=340*distan3/2/10000;

  270.                                 
  271.                                         TIM2CH3_CAPTURE_STA=0;
  272.                                    TIM_OC3PolarityConfig(TIM2,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  273.                         }else                                                                  //还未开始,第一次捕获上升沿
  274.                         {
  275.                                 TIM2CH3_CAPTURE_STA=0;                        //清空
  276.                                 TIM2CH3_CAPTURE_VAL=0;
  277.                                  TIM_SetCounter(TIM2,0);
  278.                                 TIM2CH3_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  279.                                    TIM_OC3PolarityConfig(TIM2,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  280.                         }                    
  281.                 }                                                                                    
  282.          }
  283.         
  284.         if((TIM2CH4_CAPTURE_STA&0X80)==0)//还未成功捕获        
  285.         {         
  286.                 if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)         
  287.                 {            
  288.                         if(TIM2CH4_CAPTURE_STA&0X40)//已经捕获到高电平了
  289.                         {
  290.                                 if((TIM2CH4_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  291.                                 {
  292.                                         TIM2CH4_CAPTURE_STA|=0X80;//标记成功捕获了一次
  293.                                         TIM2CH4_CAPTURE_VAL=0XFFFF;
  294.                                 }else TIM2CH4_CAPTURE_STA++;
  295.                         }         
  296.                 }
  297.         if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)//捕获1发生捕获事件
  298.                 {        
  299.                         if(TIM2CH4_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  300.                         {                                 
  301.                                         TIM2CH4_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  302.                                         TIM2CH4_CAPTURE_VAL=TIM_GetCapture4(TIM2);
  303.                                 

  305.                                         distan4=TIM2CH4_CAPTURE_STA&0X3F;
  306.                                         distan4*=65536;//溢出时间总和
  307.                                         distan4+=TIM2CH4_CAPTURE_VAL;//得到总的高电平时间
  308.                                         distan4=340*distan4/2/10000;

  310.                                 
  311.                                         TIM2CH4_CAPTURE_STA=0;
  312.                                    TIM_OC4PolarityConfig(TIM2,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  313.                         }else                                                                  //还未开始,第一次捕获上升沿
  314.                         {
  315.                                 TIM2CH4_CAPTURE_STA=0;                        //清空
  316.                                 TIM2CH4_CAPTURE_VAL=0;
  317.                                  TIM_SetCounter(TIM2,0);
  318.                                 TIM2CH4_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  319.                                    TIM_OC4PolarityConfig(TIM2,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  320.                         }                    
  321.                 }                                                                                    
  322.          }
  323.         
  324.         TIM_ClearITPendingBit(TIM2, TIM_IT_CC1| TIM_IT_CC2| TIM_IT_CC3| TIM_IT_CC4|TIM_IT_Update); //清除中断标志位
  325. }        


  328. //***********************************************************************************
  329. //***********************************************************************************


  332. void TIM4_IRQHandler(void)
  333. {
  334.         
  335.         
  336.         
  337.         if((TIM4CH1_CAPTURE_STA&0X80)==0)//还未成功捕获        
  338.         {         
  339.                 if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)         
  340.                 {            
  341.                         if(TIM4CH1_CAPTURE_STA&0X40)//已经捕获到高电平了
  342.                         {
  343.                                 if((TIM4CH1_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  344.                                 {
  345.                                         TIM4CH1_CAPTURE_STA|=0X80;//标记成功捕获了一次
  346.                                         TIM4CH1_CAPTURE_VAL=0XFFFF;
  347.                                 }else TIM4CH1_CAPTURE_STA++;
  348.                         }         
  349.                 }
  350.         if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET)//捕获1发生捕获事件
  351.                 {        
  352.                         if(TIM4CH1_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  353.                         {                                 
  354.                                         TIM4CH1_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  355.                                         TIM4CH1_CAPTURE_VAL=TIM_GetCapture1(TIM4);
  356.                                 

  358.                                         distan5=TIM4CH1_CAPTURE_STA&0X3F;
  359.                                         distan5*=65536;//溢出时间总和
  360.                                         distan5+=TIM4CH1_CAPTURE_VAL;//得到总的高电平时间
  361.                                         distan5=340*distan5/2/10000;

  363.                                 
  364.                                         TIM4CH1_CAPTURE_STA=0;
  365.                                    TIM_OC1PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  366.                         }else                                                                  //还未开始,第一次捕获上升沿
  367.                         {
  368.                                 TIM4CH1_CAPTURE_STA=0;                        //清空
  369.                                 TIM4CH1_CAPTURE_VAL=0;
  370.                                  TIM_SetCounter(TIM4,0);
  371.                                 TIM4CH1_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  372.                                    TIM_OC1PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  373.                         }                    
  374.                 }                                                                                    
  375.          }
  376.         
  377.         
  378.         
  379.         if((TIM4CH2_CAPTURE_STA&0X80)==0)//还未成功捕获        
  380.         {         
  381.                 if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
  382.                  
  383.                 {            
  384.                         if(TIM4CH2_CAPTURE_STA&0X40)//已经捕获到高电平了
  385.                         {
  386.                                 if((TIM4CH2_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  387.                                 {
  388.                                         TIM4CH2_CAPTURE_STA|=0X80;//标记成功捕获了一次
  389.                                         TIM4CH2_CAPTURE_VAL=0XFFFF;
  390.                                 }else TIM4CH2_CAPTURE_STA++;
  391.                         }         
  392.                 }
  393.         if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET)//捕获1发生捕获事件
  394.                 {        
  395.                         if(TIM4CH2_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  396.                         {                                 
  397.                                         TIM4CH2_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  398.                                         TIM4CH2_CAPTURE_VAL=TIM_GetCapture2(TIM4);
  399.                                         distan6=TIM4CH2_CAPTURE_STA&0X3F;
  400.                                         distan6*=65536;//溢出时间总和
  401.                                         distan6+=TIM4CH2_CAPTURE_VAL;//得到总的高电平时间
  402.                                         distan6=340*distan6/2/10000;

  404.                                 
  405.                                         TIM4CH2_CAPTURE_STA=0;
  406.                                    TIM_OC2PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  407.                         }else                                                                  //还未开始,第一次捕获上升沿
  408.                         {
  409.                                 TIM4CH2_CAPTURE_STA=0;                        //清空
  410.                                 TIM4CH2_CAPTURE_VAL=0;
  411.                                  TIM_SetCounter(TIM4,0);
  412.                                 TIM4CH2_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  413.                                    TIM_OC2PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  414.                         }                    
  415.                 }                                                                                    
  416.          }
  417.         
  418.         
  419.                 if((TIM4CH3_CAPTURE_STA&0X80)==0)//还未成功捕获        
  420.         {         
  421.                 if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
  422.                  
  423.                 {            
  424.                         if(TIM4CH3_CAPTURE_STA&0X40)//已经捕获到高电平了
  425.                         {
  426.                                 if((TIM4CH3_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  427.                                 {
  428.                                         TIM4CH3_CAPTURE_STA|=0X80;//标记成功捕获了一次
  429.                                         TIM4CH3_CAPTURE_VAL=0XFFFF;
  430.                                 }else TIM4CH3_CAPTURE_STA++;
  431.                         }         
  432.                 }
  433.         if (TIM_GetITStatus(TIM4, TIM_IT_CC3) != RESET)//捕获1发生捕获事件
  434.                 {        
  435.                         if(TIM4CH3_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  436.                         {                                 
  437.                                         TIM4CH3_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  438.                                         TIM4CH3_CAPTURE_VAL=TIM_GetCapture3(TIM4);
  439.                                         distan7=TIM4CH3_CAPTURE_STA&0X3F;
  440.                                         distan7*=65536;//溢出时间总和
  441.                                         distan7+=TIM4CH3_CAPTURE_VAL;//得到总的高电平时间
  442.                                         distan7=340*distan7/2/10000;

  444.                                 
  445.                                         TIM4CH3_CAPTURE_STA=0;
  446.                                    TIM_OC3PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  447.                         }else                                                                  //还未开始,第一次捕获上升沿
  448.                         {
  449.                                 TIM4CH3_CAPTURE_STA=0;                        //清空
  450.                                 TIM4CH3_CAPTURE_VAL=0;
  451.                                  TIM_SetCounter(TIM4,0);
  452.                                 TIM4CH3_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  453.                            TIM_OC3PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  454.                         }                    
  455.                 }                                                                                    
  456.          }
  457.         
  458.         
  459.                 if((TIM4CH4_CAPTURE_STA&0X80)==0)//还未成功捕获        
  460.         {         
  461.                 if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
  462.                  
  463.                 {            
  464.                         if(TIM4CH4_CAPTURE_STA&0X40)//已经捕获到高电平了
  465.                         {
  466.                                 if((TIM4CH4_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
  467.                                 {
  468.                                         TIM4CH4_CAPTURE_STA|=0X80;//标记成功捕获了一次
  469.                                         TIM4CH4_CAPTURE_VAL=0XFFFF;
  470.                                 }else TIM4CH4_CAPTURE_STA++;
  471.                         }         
  472.                 }
  473.         if (TIM_GetITStatus(TIM4, TIM_IT_CC4) != RESET)//捕获1发生捕获事件
  474.                 {        
  475.                         if(TIM4CH4_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
  476.                         {                                 
  477.                                         TIM4CH4_CAPTURE_STA|=0X80;                //标记成功捕获到一次上升沿
  478.                                         TIM4CH4_CAPTURE_VAL=TIM_GetCapture4(TIM4);
  479.                                         distan8=TIM4CH4_CAPTURE_STA&0X3F;
  480.                                         distan8*=65536;//溢出时间总和
  481.                                         distan8+=TIM4CH4_CAPTURE_VAL;//得到总的高电平时间
  482.                                         distan8=340*distan8/2/10000;

  484.                                 
  485.                                         TIM4CH4_CAPTURE_STA=0;
  486.                                    TIM_OC4PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
  487.                         }else                                                                  //还未开始,第一次捕获上升沿
  488.                         {
  489.                                 TIM4CH4_CAPTURE_STA=0;                        //清空
  490.                                 TIM4CH4_CAPTURE_VAL=0;
  491.                                  TIM_SetCounter(TIM4,0);
  492.                                 TIM4CH4_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
  493.                                    TIM_OC4PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获
  494.                         }                    
  495.                 }                                                                                    
  496.          }
  497.         
  498.         
  499.         TIM_ClearITPendingBit(TIM4, TIM_IT_CC1| TIM_IT_CC2| TIM_IT_CC3| TIM_IT_CC4|TIM_IT_Update); //清除中断标志位
  500. }        
复制代码


全部资料51hei下载地址：
TIM2和TIM4八超声波.7z (183.58 KB, 下载次数: 23)
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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