STM32F103配置三个定时器10个通道，进行输入捕获测试，串口输出结果

sher2018

用STM32F103ZET6的三个定时器TIM3，TIM4，TIM5配置10个通道  ，进行按键输入捕获// 0 PA0 TIM5_CH1// 1 PA1 TIM5_CH2
// 2 PA6 TIM3_CH1
// 3 PA7 TIM3_CH2
// 4 PB0 TIM3_CH3
// 5 PB1 TIM3_CH4
// 6 PB6 TIM4_CH1
// 7 PB7 TIM4_CH2
// 8 PB8 TIM4_CH3
// 9 PB9 TIM4_CH4


现在不清楚是定时器什么地方配置出错还是IO配置有问题，怎么按键串口都没反应，用正点战舰开发板的wakeup键作TIM5_CH1的按键输入捕获，但是没有结果
求各位大神各位大佬指点迷津

代码如下：
一、ten_key.c
#include "ten_key.h"


void Ten_Key_Init(void)
{
        GPIO_InitTypeDef GPIO_InitStruct;
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);
        // 0 PA0 TIM5_CH1
        // 1 PA1 TIM5_CH2
        // 2 PA6 TIM3_CH1
        // 3 PA7 TIM3_CH2
        GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPD;
        GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_6 | GPIO_Pin_7;
        GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOA, &GPIO_InitStruct);
        
        // 4 PB0 TIM3_CH3
        // 5 PB1 TIM3_CH4
        // 6 PB6 TIM4_CH1
        // 7 PB7 TIM4_CH2
        // 8 PB8 TIM4_CH3
        // 9 PB9 TIM4_CH4
        GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPD;
        GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;
        GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStruct);
}



二、ten_timer.c


#include "ten_timer.h"
#include "ten_key.h"


TIM_ICInitTypeDef TIM5_ICInitStruct;
TIM_ICInitTypeDef TIM3_ICInitStruct;
TIM_ICInitTypeDef TIM4_ICInitStruct;




void Ten_TIM_Cap_Init(u16 arr, u16 psc)
{
        TIM_TimeBaseInitTypeDef TIM5_TimeBaseInitStruct;
        TIM_TimeBaseInitTypeDef TIM3_TimeBaseInitStruct;
        TIM_TimeBaseInitTypeDef TIM4_TimeBaseInitStruct;
        
        NVIC_InitTypeDef NVIC_InitStruct;
        
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3 | RCC_APB1Periph_TIM4 | RCC_APB1Periph_TIM5, ENABLE);
        
        Ten_Key_Init();
        
        // TIM5
        TIM5_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
        TIM5_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
        TIM5_TimeBaseInitStruct.TIM_Period = arr;
        TIM5_TimeBaseInitStruct.TIM_Prescaler = psc;
        TIM_TimeBaseInit(TIM5, &TIM5_TimeBaseInitStruct);
        
        // 0 PA0 TIM5_CH1
        // 1 PA1 TIM5_CH2
        TIM5_ICInitStruct.TIM_Channel = TIM_Channel_1 | TIM_Channel_2;
        TIM5_ICInitStruct.TIM_ICFilter = 0x9;
        TIM5_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM5_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM5_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInit(TIM5, &TIM5_ICInitStruct);
        
        // TIM3
        TIM3_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
        TIM3_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
        TIM3_TimeBaseInitStruct.TIM_Period = arr;
        TIM3_TimeBaseInitStruct.TIM_Prescaler = psc;
        TIM_TimeBaseInit(TIM3, &TIM3_TimeBaseInitStruct);
        
        // 2 PA6 TIM3_CH1        
        // 3 PA7 TIM3_CH2        
        // 4 PB0 TIM3_CH3        
        // 5 PB1 TIM3_CH4
        TIM3_ICInitStruct.TIM_Channel = TIM_Channel_1 | TIM_Channel_2 | TIM_Channel_3 | TIM_Channel_4;
        TIM3_ICInitStruct.TIM_ICFilter = 0x9;
        TIM3_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM3_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM3_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInit(TIM3, &TIM3_ICInitStruct);
        
        // TIM4
        TIM4_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
        TIM4_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
        TIM4_TimeBaseInitStruct.TIM_Period = arr;
        TIM4_TimeBaseInitStruct.TIM_Prescaler = psc;
        TIM_TimeBaseInit(TIM4, &TIM4_TimeBaseInitStruct);
        
        // 6 PB6 TIM4_CH1
        // 7 PB7 TIM4_CH2
        // 8 PB8 TIM4_CH3
        // 9 PB9 TIM4_CH4
        TIM4_ICInitStruct.TIM_Channel = TIM_Channel_1 | TIM_Channel_2 | TIM_Channel_3 | TIM_Channel_4;
        TIM4_ICInitStruct.TIM_ICFilter = 0x9;
        TIM4_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM4_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM4_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInit(TIM4, &TIM4_ICInitStruct);
        
        // 中断配置
        NVIC_InitStruct.NVIC_IRQChannel = TIM5_IRQn | TIM3_IRQn | TIM4_IRQn;
        NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
        NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
        NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
        NVIC_Init(&NVIC_InitStruct);
        // 主函数中加入NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
        
        // TIM5
        TIM_ITConfig(TIM5,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2, ENABLE);
        
        TIM_Cmd(TIM5, ENABLE);
        // TIM3
        TIM_ITConfig(TIM3,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3 | TIM_IT_CC4, ENABLE);
        
        TIM_Cmd(TIM3, ENABLE);
        // TIM4
        TIM_ITConfig(TIM4,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3 | TIM_IT_CC4, ENABLE);
        
        TIM_Cmd(TIM4, ENABLE);
}

sher2018

// 中断服务函数
u8  TIM5CH1_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM5CH1_CAPTURE_VAL;        //输入捕获值
u8  TIM5CH2_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM5CH2_CAPTURE_VAL;        //输入捕获值
  // 0 PA0 TIM5_CH1
  // 1 PA1 TIM5_CH2
void TIM5_IRQHandler(void)
{
  // 0 PA0 TIM5_CH1
        if((TIM5CH1_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM5, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM5CH1_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM5CH1_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM5CH1_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM5CH1_CAPTURE_VAL=0XFFFF;
                                }else TIM5CH1_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM5, TIM_IT_CC1) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM5CH1_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM5CH1_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM5CH1_CAPTURE_VAL=TIM_GetCapture1(TIM5);
                                   TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM5CH1_CAPTURE_STA=0;                        //清空
                                TIM5CH1_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM5,0); // 计数器设置为0，开始计数
                                TIM5CH1_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM5, TIM_IT_CC1|TIM_IT_Update); //清除中断标志位
        
  // 1 PA1 TIM5_CH2
        if((TIM5CH2_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM5, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM5CH2_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM5CH2_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM5CH2_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM5CH2_CAPTURE_VAL=0XFFFF;
                                }else TIM5CH2_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM5, TIM_IT_CC2) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM5CH2_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM5CH2_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM5CH2_CAPTURE_VAL=TIM_GetCapture2(TIM5);
                                   TIM_OC2PolarityConfig(TIM5,TIM_ICPolarity_Rising); //CC2P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM5CH2_CAPTURE_STA=0;                        //清空
                                TIM5CH2_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM5,0); // 计数器设置为0，开始计数
                                TIM5CH2_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC2PolarityConfig(TIM5,TIM_ICPolarity_Falling);                //CC2P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM5, TIM_IT_CC2|TIM_IT_Update); //清除中断标志位

}

sher2018

// 2 PA6 TIM3_CH1
        
  // 3 PA7 TIM3_CH2
        
        // 4 PB0 TIM3_CH3
        
        // 5 PB1 TIM3_CH4
u8  TIM3CH1_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM3CH1_CAPTURE_VAL;        //输入捕获值
u8  TIM3CH2_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM3CH2_CAPTURE_VAL;        //输入捕获值
u8  TIM3CH3_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM3CH3_CAPTURE_VAL;        //输入捕获值
u8  TIM3CH4_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM3CH4_CAPTURE_VAL;        //输入捕获值

void TIM3_IRQHandler(void)
{
  // 2 PA6 TIM3_CH1
        if((TIM3CH1_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM3CH1_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM3CH1_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM3CH1_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM3CH1_CAPTURE_VAL=0XFFFF;
                                }else TIM3CH1_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM3CH1_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM3CH1_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM3CH1_CAPTURE_VAL=TIM_GetCapture1(TIM3);
                                   TIM_OC1PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM3CH1_CAPTURE_STA=0;                        //清空
                                TIM3CH1_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM3,0); // 计数器设置为0，开始计数
                                TIM3CH1_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC1PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM3, TIM_IT_CC1|TIM_IT_Update); //清除中断标志位
        
  // 3 PA7 TIM3_CH2
        if((TIM3CH2_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM3CH2_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM3CH2_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM3CH2_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM3CH2_CAPTURE_VAL=0XFFFF;
                                }else TIM3CH2_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM3CH2_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM3CH2_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM3CH2_CAPTURE_VAL=TIM_GetCapture2(TIM5);
                                   TIM_OC2PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC2P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM3CH2_CAPTURE_STA=0;                        //清空
                                TIM3CH2_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM3,0); // 计数器设置为0，开始计数
                                TIM3CH2_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC2PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC2P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM3, TIM_IT_CC2|TIM_IT_Update); //清除中断标志位
        
        // 4 PB0 TIM3_CH3
        if((TIM3CH3_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM3CH3_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM3CH3_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM3CH3_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM3CH3_CAPTURE_VAL=0XFFFF;
                                }else TIM3CH3_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM3CH3_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM3CH3_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM3CH3_CAPTURE_VAL=TIM_GetCapture3(TIM3);
                                   TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC3P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM3CH3_CAPTURE_STA=0;                        //清空
                                TIM3CH3_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM3,0); // 计数器设置为0，开始计数
                                TIM3CH3_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC3PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC3P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM3, TIM_IT_CC3|TIM_IT_Update); //清除中断标志位
        
        // 5 PB1 TIM3_CH4
if((TIM3CH4_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM3CH4_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM3CH4_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM3CH4_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM3CH4_CAPTURE_VAL=0XFFFF;
                                }else TIM3CH4_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM3CH4_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM3CH4_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM3CH4_CAPTURE_VAL=TIM_GetCapture4(TIM3);
                                   TIM_OC4PolarityConfig(TIM3,TIM_ICPolarity_Rising); //CC4P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM3CH4_CAPTURE_STA=0;                        //清空
                                TIM3CH4_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM3,0); // 计数器设置为0，开始计数
                                TIM3CH4_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC4PolarityConfig(TIM3,TIM_ICPolarity_Falling);                //CC4P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM3, TIM_IT_CC4|TIM_IT_Update); //清除中断标志位
}

sher2018

// 6 PB6 TIM4_CH1
        
        // 7 PB7 TIM4_CH2
        
        // 8 PB8 TIM4_CH3
        
        // 9 PB9 TIM4_CH4
u8  TIM4CH1_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM4CH1_CAPTURE_VAL;        //输入捕获值
u8  TIM4CH2_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM4CH2_CAPTURE_VAL;        //输入捕获值
u8  TIM4CH3_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM4CH3_CAPTURE_VAL;        //输入捕获值
u8  TIM4CH4_CAPTURE_STA=0;        //输入捕获状态                                                   
u16        TIM4CH4_CAPTURE_VAL;        //输入捕获值

void TIM4_IRQHandler(void)
{
  // 6 PB6 TIM4_CH1
        if((TIM4CH1_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM4CH1_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM4CH1_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM4CH1_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM4CH1_CAPTURE_VAL=0XFFFF;
                                }else TIM4CH1_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM4CH1_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM4CH1_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM4CH1_CAPTURE_VAL=TIM_GetCapture1(TIM4);
                                   TIM_OC1PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC1P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM4CH1_CAPTURE_STA=0;                        //清空
                                TIM4CH1_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM4,0); // 计数器设置为0，开始计数
                                TIM4CH1_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC1PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC1P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM4, TIM_IT_CC1|TIM_IT_Update); //清除中断标志位
        
  // 7 PB7 TIM4_CH2
        if((TIM4CH2_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM4CH2_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM4CH2_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM4CH2_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM4CH2_CAPTURE_VAL=0XFFFF;
                                }else TIM4CH2_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM4CH2_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM4CH2_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM4CH2_CAPTURE_VAL=TIM_GetCapture2(TIM4);
                                   TIM_OC2PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC2P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM4CH2_CAPTURE_STA=0;                        //清空
                                TIM4CH2_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM4,0); // 计数器设置为0，开始计数
                                TIM4CH2_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC2PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC2P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM4, TIM_IT_CC2|TIM_IT_Update); //清除中断标志位
        
        // 8 PB8 TIM4_CH3
        if((TIM4CH3_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM4CH3_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM4CH3_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM4CH3_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM4CH3_CAPTURE_VAL=0XFFFF;
                                }else TIM4CH3_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM4, TIM_IT_CC3) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM4CH3_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM4CH3_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM4CH3_CAPTURE_VAL=TIM_GetCapture3(TIM4);
                                   TIM_OC3PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC3P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM4CH3_CAPTURE_STA=0;                        //清空
                                TIM4CH3_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM4,0); // 计数器设置为0，开始计数
                                TIM4CH3_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC3PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC3P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM4, TIM_IT_CC3|TIM_IT_Update); //清除中断标志位
        
        // 9 PB9 TIM4_CH4
if((TIM4CH4_CAPTURE_STA&0X80)==0)//还未成功捕获        
        {         
                if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
                 
                {            
                        if(TIM4CH4_CAPTURE_STA&0X40)//已经捕获到高电平了
                        {
                                if((TIM4CH4_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
                                {
                                        TIM4CH4_CAPTURE_STA|=0X80;//标记成功捕获了一次
                                        TIM4CH4_CAPTURE_VAL=0XFFFF;
                                }else TIM4CH4_CAPTURE_STA++;
                        }         
                }
        if (TIM_GetITStatus(TIM4, TIM_IT_CC4) != RESET)//捕获1发生捕获事件
                {        
                        if(TIM4CH4_CAPTURE_STA&0X40)                //捕获到一个下降沿                 
                        {                                 
                                TIM4CH4_CAPTURE_STA|=0X80;                //标记成功捕获到一次高电平脉宽
                                TIM4CH4_CAPTURE_VAL=TIM_GetCapture4(TIM4);
                                   TIM_OC4PolarityConfig(TIM4,TIM_ICPolarity_Rising); //CC4P=0 设置为上升沿捕获
                        }else                                                                  //还未开始,第一次捕获上升沿
                        {
                                TIM4CH4_CAPTURE_STA=0;                        //清空
                                TIM4CH4_CAPTURE_VAL=0;
                                 TIM_SetCounter(TIM4,0); // 计数器设置为0，开始计数
                                TIM4CH4_CAPTURE_STA|=0X40;                //标记捕获到了上升沿
                                   TIM_OC4PolarityConfig(TIM4,TIM_ICPolarity_Falling);                //CC4P=1 设置为下降沿捕获，等待下降沿到来
                        }                    
                }                                                                                    
        }

    TIM_ClearITPendingBit(TIM4, TIM_IT_CC4|TIM_IT_Update); //清除中断标志位
}

sher2018

三、main函数
#include "stm32f10x.h"
#include "sys.h"
#include "ten_timer.h"
#include "ten_key.h"
#include "delay.h"
#include "usart.h"
extern u8   TIM5CH1_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM5CH1_CAPTURE_VAL;        //输入捕获值
extern u8   TIM5CH2_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM5CH2_CAPTURE_VAL;        //输入捕获值
extern u8   TIM3CH1_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM3CH1_CAPTURE_VAL;        //输入捕获值
extern u8   TIM3CH2_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM3CH2_CAPTURE_VAL;        //输入捕获值
extern u8   TIM3CH3_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM3CH3_CAPTURE_VAL;        //输入捕获值
extern u8   TIM3CH4_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM3CH4_CAPTURE_VAL;        //输入捕获值
extern u8   TIM4CH1_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM4CH1_CAPTURE_VAL;        //输入捕获值
extern u8   TIM4CH2_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM4CH2_CAPTURE_VAL;        //输入捕获值
extern u8   TIM4CH3_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM4CH3_CAPTURE_VAL;        //输入捕获值
extern u8   TIM4CH4_CAPTURE_STA;                //输入捕获状态                                                   
extern u16        TIM4CH4_CAPTURE_VAL;        //输入捕获值

void Delay(u32 count)
{
   u32 i=0;
   for(;i<count;i++);
}


int main(void)
{        
         u32 temp=0;
         delay_init();
         uart_init(115200);
         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);         //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   Ten_TIM_Cap_Init(0XFFFF,7200-1); // 1ms
         
  while(1)
        {
               
                delay_ms(10);
                // 0 PA0 TIM5_CH1
    if(TIM5CH1_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM5CH1_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM5CH1_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM5CH1_CAPTURE_STA=0;//开启下一次捕获
                }
               
                // 1 PA1 TIM5_CH2
                if(TIM5CH2_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM5CH2_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM5CH2_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM5CH2_CAPTURE_STA=0;//开启下一次捕获
                }
               
                // 2 PA6 TIM3_CH1        
                if(TIM3CH1_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM3CH1_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM3CH1_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM3CH1_CAPTURE_STA=0;//开启下一次捕获
                }
               
    // 3 PA7 TIM3_CH2        
                if(TIM3CH2_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM3CH2_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM3CH2_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM3CH2_CAPTURE_STA=0;//开启下一次捕获
                }
               
          // 4 PB0 TIM3_CH3        
                if(TIM3CH3_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM3CH3_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM3CH3_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM3CH3_CAPTURE_STA=0;//开启下一次捕获
                }
               
          // 5 PB1 TIM3_CH4
                if(TIM3CH4_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM3CH4_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM3CH4_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp); //打印总的高点平时间
                        TIM3CH4_CAPTURE_STA=0;//开启下一次捕获
                }
               
                // 6 PB6 TIM4_CH1
                if(TIM4CH1_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM4CH1_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM4CH1_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM4CH1_CAPTURE_STA=0;//开启下一次捕获
                }
               
          // 7 PB7 TIM4_CH2
                if(TIM4CH2_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM4CH2_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM4CH2_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM4CH2_CAPTURE_STA=0;//开启下一次捕获
                }
               
          // 8 PB8 TIM4_CH3
                if(TIM4CH3_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM4CH3_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM4CH3_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM4CH3_CAPTURE_STA=0;//开启下一次捕获
                }
               
          // 9 PB9 TIM4_CH4
                if(TIM4CH4_CAPTURE_STA&0X80)//成功捕获到了一次上升沿
                {
                        temp=TIM4CH4_CAPTURE_STA&0X3F;
                        temp*=65536;//溢出时间总和
                        temp+=TIM4CH4_CAPTURE_VAL;//得到总的高电平时间
                        printf("HIGH:%d ms\r\n",temp);//打印总的高点平时间
                        TIM4CH4_CAPTURE_STA=0;//开启下一次捕获
                }               
        }
}

正点原子

帮顶

HXYDJ

先调通一个通道，在慢慢往上增加通道。

sher2018

现在解决了一点点就是中断分组配置错了，串口终于有数据显示了，但是依然是0或者65535，不能获得正确的按键时长       
// 中断配置

        // 主函数中加入NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
       
        // TIM5
        NVIC_InitStructTIM5.NVIC_IRQChannel = TIM5_IRQn;
        NVIC_InitStructTIM5.NVIC_IRQChannelCmd = ENABLE;
        NVIC_InitStructTIM5.NVIC_IRQChannelPreemptionPriority = 2;
        NVIC_InitStructTIM5.NVIC_IRQChannelSubPriority = 0;
        NVIC_Init(&NVIC_InitStructTIM5);
       
        TIM_ITConfig(TIM5,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2, ENABLE);
       
        TIM_Cmd(TIM5, ENABLE);
        // TIM3
        NVIC_InitStructTIM3.NVIC_IRQChannel = TIM3_IRQn;
        NVIC_InitStructTIM3.NVIC_IRQChannelCmd = ENABLE;
        NVIC_InitStructTIM3.NVIC_IRQChannelPreemptionPriority = 2;
        NVIC_InitStructTIM3.NVIC_IRQChannelSubPriority = 0;
        NVIC_Init(&NVIC_InitStructTIM3);
       
        TIM_ITConfig(TIM3,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3 | TIM_IT_CC4, ENABLE);
       
        TIM_Cmd(TIM3, ENABLE);
        // TIM4
        NVIC_InitStructTIM4.NVIC_IRQChannel = TIM4_IRQn;
        NVIC_InitStructTIM4.NVIC_IRQChannelCmd = ENABLE;
        NVIC_InitStructTIM4.NVIC_IRQChannelPreemptionPriority = 2;
        NVIC_InitStructTIM4.NVIC_IRQChannelSubPriority = 0;
        NVIC_Init(&NVIC_InitStructTIM4);
       
        TIM_ITConfig(TIM4,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3 | TIM_IT_CC4, ENABLE);
       
        TIM_Cmd(TIM4, ENABLE);

sher2018

HXYDJ 发表于 2018-9-17 08:49
先调通一个通道，在慢慢往上增加通道。

一个通道都没调通我就不会费这么大劲发帖子了你帮忙看看么大佬

HXYDJ

sher2018 发表于 2018-9-17 09:53
一个通道都没调通我就不会费这么大劲发帖子了你帮忙看看么大佬

那你就一个通道一个通道往上增加，看增加到第几个通道时出问题了，然后再去慢慢分析原因。

1208

TIM5_ICInitStructure.TIM_Channel = TIM_Channel_1|TIM_Channel_2;
以上这行代码是错误的，导致你的中断函数根本没初始化起来：
TIM_ICInit(TIM5, &TIM5_ICInitStructure); //这个函数根本没起作用

sher2018

1208 发表于 2018-9-17 17:42
TIM5_ICInitStructure.TIM_Channel = TIM_Channel_1|TIM_Channel_2;
以上这行代码是错误的，导致你的中断 ...

嗯嗯，谢谢！我在后面的帖子说了这个问题，但是出的结果还是错的，只出0或者65535

1208

sher2018 发表于 2018-9-18 10:16
嗯嗯，谢谢！我在后面的帖子说了这个问题，但是出的结果还是错的，只出0或者65535

我没改之前会出现65535，改了就可以通过按键控制了