蓝桥杯嵌入式入坑系列 ----省赛第五届:双通道方波频率检测与倍频输出

最新推荐文章于 2023-07-06 14:15:46 发布
最新推荐文章于 2023-07-06 14:15:46 发布
阅读量846 收藏 5
点赞数 3
分类专栏： 蓝桥杯嵌入式 文章标签： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44236302/article/details/104426456
版权 
/*赛题：第五届:双通道方波频率检测与倍频输出
**时间：2020-2-10
**注意：输入捕获的配置多理解  输出比较模式
**提醒：由于本题没有让LCD显示串口打印的内容，所以自己根据题意设置CH1  CH2显示不同的通道
*/

#include "stm32f10x.h"
#include "lcd.h"
#include "led.h"
#include "key.h"
#include "stdio.h"
#include "i2c.h"
#include "pwm.h"
#include "usart.h"

**第一部分**
/***************函数名的定义**** *****************/
u32 TimingDelay = 0;   //滴答定时器计数变量

u8 RXCOUNT = 0;        //串口接收计数变量
u8 RXBUF[20];          //串口接收数组变量
u8 RXOVER = 0;         //串口接收完成变量
u8 count = 0;          //串口接收位数变量
u8 i;                  //串口接收清除变量
u8 usart_flag =0;      //串口使能切换变量

u8 text1[20];          //LCD输出字符串变量1
u8 text2[20];          //LCD输出字符串变量2
u8 text3[20];          //LCD输出字符串变量3
u8 text4[20];          //LCD输出字符串变量4
u16 fre_1 = 0;       //通道1的频率
u16 fre_2 = 0;       //通道2的频率
u8 per_1 = 2;          //通道1的倍频
u8 per_2 = 2;          //通道2的倍频
u8 key1_temp = 0;      //“K1”按键：用于切换“本地设定”和“串口设定”。
u8 key2_temp = 0;      //“K2”按键：用于在两个通道之间来回切换
//u8 key3_temp = 0;      //“K3”按键：对当前通道的倍频数减 1，减到 1 时停止减数
//u8 key4_temp = 0;      //“K4”按键：对当前通道的倍频数加 1，加到 10 时停止加数；


/***************变量名的声明*********************/
extern u8 TIM2_CH2_CAPTURE_MODE;    //用来记录当前捕获在哪个位置
extern u32 TIM2_CH2_CAPTURE_HL;     //用来记录第二次捕获的时间
extern u8 TIM2_CH3_CAPTURE_MODE;    //用来记录当前捕获在哪个位置
extern u32 TIM2_CH3_CAPTURE_HL;     //用来记录第二次捕获的时间

/***************函数名的声明*********************/
void Delay_Ms(u32 nTime);
void RCC_Configuration(void);
void Scan_Key(void);
void LCD_Init(void);
void LCD_Display(void);
void PWM_IN_Frequency(void);
void _24c02_Write(u16 adr,u16 data);
u16 _24c02_Read(u16 adr);

/***************Main Body*********************/
int main(void)
{
	i2c_init();	
	LCD_Init();   
	RCC_Configuration();                //先外设开启时钟
	USART2_Configuration();
	TIM2_Configuration();
	TIM3_Configuration(1000,300);
	KEY_Configuration();
	LED_Configuration();
	while(1)
	{
		PWM_IN_Frequency();     
		LCD_Display();
		Scan_Key();
	}
}

/***************LCD_Init*********************/
void LCD_Init(void)
{
	SysTick_Config(SystemCoreClock/1000);	
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(Blue);
	LCD_SetTextColor(White);	
//	_24c02_Write(0x01,2);
//	Delay_Ms(10);          //写函数之后间隔一段时间，确保写入完成
//	_24c02_Write(0x02,2);
//	Delay_Ms(10);
	per_1 = _24c02_Read(0x01);
	Delay_Ms(10);
	per_2 = _24c02_Read(0x02);	
	Delay_Ms(10);
}

/***************LCD_Display*********************/
void LCD_Display(void)
{
	sprintf((char*)text1,"Channel(1): %dHz    ",fre_1);
	LCD_DisplayStringLine(Line2,text1);
	sprintf((char*)text2,"N(1): %d            ",per_1);
	LCD_DisplayStringLine(Line3,text2);
	sprintf((char*)text3,"Channel(2): %dHz    ",fre_2);
	LCD_DisplayStringLine(Line4,text3);
	sprintf((char*)text4,"N(2): %d            ",per_2);
	LCD_DisplayStringLine(Line5,text4);
	
	if(usart_flag == 1)
	{
		if(RXOVER == 1)
		{
			RXOVER = 0;					
//			LCD_ClearLine(Line7);
//			LCD_DisplayStringLine(Line7,RXBUF);	  //本题没让显示发送的内容
			switch(RXBUF[4] - 48)  //判断是哪个通道
			{
				case   1:per_1 = (RXBUF[6] - 0x30);
								 if((RXBUF[6] - 0x30) == 1) per_1 =10;  //根据题意判断是否是10
								 LED_Control(LED1,0);
								 LED_Control(LED2,1);
								 break;
				
				case   2:per_2 = (RXBUF[6] - 0x30);
								 if((RXBUF[6] - 0x30) == 1) per_2 =10;  //根据题意判断是否是10
								 LED_Control(LED1,1);
								 LED_Control(LED2,0);
								 break;	
				default: break;			
			}	
			for(i=0;i<20;i++)
			{
				RXBUF[i]=0;
			}			
			USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);
		}	
	}
}
/***************Delay_Ms*********************/
//入口参数：延时时间
void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}
/***************Scan_Key*********************/
void Scan_Key(void)
{
	if(K1 == 0)
	{
		Delay_Ms(10);
		if(K1 == 0)
		{
			key1_temp++;
		  if(key1_temp == 1)    //表示按键按下一次 切换到串口设置
			{
				usart_flag = 1;
        LED_Control(LED1,1);
				LED_Control(LED2,1);
				LED_Control(LED3,0);
			}
			else
			{
				key1_temp = 0;
				usart_flag = 0;
				LED_Control(LED3,1);
			}		
		}
		while(K1 == 0);
	}
	if((K2 == 0) && (key1_temp == 0))
	{
		Delay_Ms(10);
		if((K2 == 0) && (key1_temp == 0))
		{
			if(key2_temp == 0)           //用于通道1
			{
				key2_temp =1;
				LED_Control(LED1,1);
				LED_Control(LED2,0);
			}
			else if(key2_temp == 1)      //用于通道2
			{
				key2_temp =0;
				LED_Control(LED1,0);
				LED_Control(LED2,1);
			}						
		}
		while(K2 == 0);
	}
	if((K3 == 0) && (key1_temp == 0))
	{
		Delay_Ms(10);
		if((K3 == 0) && (key1_temp == 0))
		{
      if(key2_temp == 0)   //通道1
			{
				if(1<per_1)
				per_1--;
				else
				per_1 = 1;
				_24c02_Write(0x01,per_1);
			}
			else if(key2_temp == 1)   //通道2
			{
				if(per_2>1)
				per_2--;
				else 
				per_2 = 1;
				_24c02_Write(0x02,per_2);
			}	
		}
		while(K3 == 0);
	}

	if((K4 == 0) && (key1_temp == 0))
	{
		Delay_Ms(10);
		if((K4 == 0) && (key1_temp == 0))
		{
      if(key2_temp == 0)   //通道1
			{
				if(per_1<10)
				per_1++;
				else 
				per_1 = 10;
				_24c02_Write(0x01,per_1);
			}
			else if(key2_temp == 1)   //通道2
			{
				if(per_2<10)
				per_2++;
				else 
				per_2 = 10;
				_24c02_Write(0x02,per_2);
			}	
		}
		while(K4 == 0);
	}
	
}
/***************PWM_IN_Frequency*********************/
void PWM_IN_Frequency(void)
{
	if(TIM2_CH2_CAPTURE_MODE == 3)
	{
		fre_1 = 1000000 / TIM2_CH2_CAPTURE_HL;
		if((fre_1 < 50) || (fre_1 > 50000))
		{
		  Ch1_Enable = 1;
			sprintf((char*)text1,"Channel(1): %dHz    ",fre_1);
			LCD_DisplayStringLine(Line2,text1);
			TIM3_Configuration(fre_1 * per_1,fre_2);
		}
		else
   {
	    Ch1_Enable = 0;
	 }
	 TIM2_CH2_CAPTURE_MODE = 0;
	}
	else if(TIM2_CH3_CAPTURE_MODE == 3)
	{
		fre_2 = 1000000 / TIM2_CH3_CAPTURE_HL;
		if((fre_2 < 50) || (fre_2 > 50000))
		{
		  Ch2_Enable = 1;
			sprintf((char*)text3,"Channel(2): %dHz    ",fre_2);
			LCD_DisplayStringLine(Line4,text3);
			TIM3_Configuration(fre_1,fre_2 * per_2);
		}
		else
   {
	   Ch2_Enable = 0;
	 }
	TIM2_CH2_CAPTURE_MODE = 0;
  }	
}

/***************RCC_Configuration*********************/
void RCC_Configuration(void)
{
	/* GPIOx enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
  /* TIM3 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
	/* USART2 enable */
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
}

/***************_24c02_Write*********************/
//入口参数：写入地址，数据
void _24c02_Write(u16 adr,u16 data)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(adr);
	I2CWaitAck();
	I2CSendByte(data);
	I2CWaitAck();
	I2CStop();
}
/***************_24c02_Read*********************/
//入口参数：读取地址
u16 _24c02_Read(u16 adr)
{
	u16 temp;
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(adr);
	I2CWaitAck();

	I2CStart();
	I2CSendByte(0xa1);
	I2CWaitAck();
	temp = I2CReceiveByte();
	I2CWaitAck();
	I2CStop();
	return temp;
}
``

**第二部分**
//初始化的配置
#include "led.h"
#define LED1 GPIO_Pin_8
#define LED2 GPIO_Pin_9
#define LED3 GPIO_Pin_10
#define LED4 GPIO_Pin_11
#define LED5 GPIO_Pin_12
#define LED6 GPIO_Pin_13
#define LED7 GPIO_Pin_14
#define LED8 GPIO_Pin_15
#define LEDALL GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15
//led初始化函数
void LED_Configuration(void)
{	
	GPIO_InitTypeDef GPIO_InitStructure;
	
	GPIO_InitStructure.GPIO_Pin = LEDALL;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_Init(GPIOD, &GPIO_InitStructure);
	
	GPIO_SetBits(GPIOD,GPIO_Pin_2);
	GPIO_SetBits(GPIOC,LEDALL);
	GPIO_ResetBits(GPIOD,GPIO_Pin_2);
}



//led控制函数
//输入参数ledx：      GPIO_Pin_x(PC8 - PC15)
//输入参数led_sta：   0:点亮   1;熄灭
void LED_Control(u16 ledx,u16 led_sta)
{
	if(led_sta == 0)
	{
		GPIO_SetBits(GPIOD,GPIO_Pin_2);
		GPIO_ResetBits(GPIOC,ledx);
		GPIO_ResetBits(GPIOD,GPIO_Pin_2);
	}	
	else
	{
		GPIO_SetBits(GPIOD,GPIO_Pin_2);
		GPIO_SetBits(GPIOC,ledx);
		GPIO_ResetBits(GPIOD,GPIO_Pin_2);		
	}
}

#include "key.h"
#define K1 GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)
#define K2 GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_8)
#define K3 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_1)
#define K4 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_2)
//按键初始化函数
void KEY_Configuration(void)
{	
	GPIO_InitTypeDef GPIO_InitStructure;
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_8;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
}

#include "usart.h"

//串口接收配置
void USART2_Configuration(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	  /* Configure USART2 RTS and USART2 Tx as alternate function push-pull */
//  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
//  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
//  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
	
  USART_InitStructure.USART_BaudRate = 9600;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No ;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_InitStructure.USART_Mode = USART_Mode_Rx;                //本题只用接收不用发送，就不会引起和定时器PA2的冲突
  USART_Init(USART2, &USART_InitStructure);
	
	  /* Enable the TIM3 global Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
	
	USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);
  /* Enable the USART2 */
  USART_Cmd(USART2, ENABLE);	
}


//串口发送函数
//void USART2_SendString(u8 *str)
//{
//	u8 index = 0;
//	do
//	{
//		USART_SendData(USART2,str[index]);		
//	  while(USART_GetFlagStatus(USART2,USART_FLAG_TXE) == RESET);//等待电平为高电平说明才发送完一字节
//		index++;
//	}
//  while(str[index] != 0);
//}

#include "pwm.h"

u32 TIM3_Ch1_Val =0;    //输出PWM通道1的占空比值
u32 TIM3_Ch2_Val =0;    //输出PWM通道2的占空比值
u8 Ch1_Enable = 1;          //通道1的使能值
u8 Ch2_Enable = 1;          //通道2的使能值


//输入捕获配置
void TIM2_Configuration(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_ICInitTypeDef  TIM_ICInitStructure;
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  NVIC_InitTypeDef NVIC_InitStructure;	
	
  /* TIM2 channe2 3 pin (P1.02) configuration */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);	

  /* TIM2 configuration: Input Capture mode ---------------------*/
  TIM_ICInitStructure.TIM_Channel = TIM_Channel_2 ;
  TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter = 0x0;	
	TIM_ICInit(TIM2, &TIM_ICInitStructure);

  TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;
  TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter = 0x0;	
	TIM_ICInit(TIM2, &TIM_ICInitStructure);
	
  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 0xffff;
  TIM_TimeBaseStructure.TIM_Prescaler = 71;
  TIM_TimeBaseStructure.TIM_ClockDivision =0x0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
	
  /* Enable the TIM3 global Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  /* TIM enable counter */
  TIM_Cmd(TIM2, ENABLE);
//	TIM_ClearFlag(TIM2, TIM_IT_CC2 | TIM_IT_CC3); //清除中断标志
  /* Enable the CC2 Interrupt Request */
  TIM_ITConfig(TIM2, TIM_IT_CC2 | TIM_IT_CC3, ENABLE);
	
}

//输出比较配置
void TIM3_Configuration(u32 ch2_fre,u32 ch3_fre)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;	
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);	
	
  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 0xffff;
  TIM_TimeBaseStructure.TIM_Prescaler = 71;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);	            //一定要注意有通道选择序号时候是不是一致
	

	TIM3_Ch1_Val = 1000000 / ch2_fre;	
	TIM3_Ch2_Val = 1000000 / ch3_fre;
	
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = TIM3_Ch1_Val;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
	if(Ch1_Enable)
	{
	   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	}
	else
	{
	  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Disable;
	}
  TIM_OC1Init(TIM3, &TIM_OCInitStructure);	
	
	if(Ch2_Enable)
	{
	   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	}
	else
	{
	  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Disable;
	}
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
  TIM_OCInitStructure.TIM_Pulse = TIM3_Ch2_Val;
  TIM_OC2Init(TIM3, &TIM_OCInitStructure);
	
  /* Enable the TIM3 global Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

//	TIM_SetCounter(TIM3, 0x0);
//	TIM_SetCompare1(TIM3, 0x0);
//	TIM_SetCompare2(TIM3, 0x0);
	TIM_ITConfig(TIM3, TIM_IT_CC1|TIM_IT_CC2 , ENABLE);   //用到中断处理的方式去
  /* TIM3 enable counter */
  TIM_Cmd(TIM3, ENABLE);
}

 **第三部分**
//中断处理函数
#include "stm32f10x_it.h"
#include "pwm.h"
extern u32 TimingDelay;
u8 CAPTURE_Flag=0;               //TIM2通道获取标志位
u16 capture = 0;                 //TIM3通道获取当前通道的值
u8 TIM2_CH2_CAPTURE_MODE = 0;    //用来记录当前捕获在哪个位置
u32 TIM2_CH2_CAPTURE_H = 0;      //用来记录第一次捕获的时间
u32 TIM2_CH2_CAPTURE_HL = 0;     //用来记录第二次捕获的时间
u8 TIM2_CH3_CAPTURE_MODE = 0;    //用来记录当前捕获在哪个位置
u32 TIM2_CH3_CAPTURE_H = 0;      //用来记录第一次捕获的时间
u32 TIM2_CH3_CAPTURE_HL = 0;     //用来记录第二次捕获的时间

extern u8 count;
extern u8 RXCOUNT;
extern u8 RXBUF[20];
extern u8 RXOVER;

//滴答中断定时
void SysTick_Handler(void)
{
  static u8 CAPTURE_sum = 0;
	TimingDelay--;
	
	if(++CAPTURE_sum == 200)
	{
	  CAPTURE_sum = 0;
		CAPTURE_Flag ^=1;
	}
}

/**********************************只可以计算频率******************************
void TIM2_IRQHandler(void)
{
	if(TIM_GetITStatus(TIM2, TIM_IT_CC2) == 1)
	{
		TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
		if(!CAPTURE_Flag)
		{
			switch(TIM2_CH2_CAPTURE_MODE)
			{
				case 0: TIM2_CH2_CAPTURE_HL = 0;
						    TIM2_CH2_CAPTURE_MODE = 1;
						    TIM_SetCounter(TIM2,0x0);
						    break;
				case 1: TIM2_CH2_CAPTURE_HL = TIM_GetCounter(TIM2);
						    TIM2_CH2_CAPTURE_MODE = 2;
						    break;
				default:break;
			}
		}else
		{
			TIM2_CH2_CAPTURE_MODE = 0;
		}
	}
		
		
	if(TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET)
	{
		TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
		if(CAPTURE_Flag)
		{
			switch(TIM2_CH3_CAPTURE_MODE)
			{
				case 0: TIM2_CH3_CAPTURE_HL = 0;
						    TIM2_CH3_CAPTURE_MODE = 1;
						    TIM_SetCounter(TIM2,0x0);
						    break;
				case 1: TIM2_CH3_CAPTURE_HL = TIM_GetCounter(TIM2);
						    TIM2_CH3_CAPTURE_MODE = 2;
						    break;
				default:break;
			}
		}else
		{
			TIM2_CH3_CAPTURE_MODE = 0;
		}
	}
}
******************************************************/

/****************可以计算频率和占空比***************/
void TIM2_IRQHandler(void)
{
	if(TIM_GetITStatus(TIM2,TIM_IT_CC2) == 1)
	{
		TIM_ClearITPendingBit(TIM2,TIM_IT_CC2);
		if(CAPTURE_Flag)
		{
				switch(TIM2_CH2_CAPTURE_MODE)
				{
					case 0: 
						      TIM2_CH2_CAPTURE_HL = 0;
					        TIM2_CH2_CAPTURE_H = 0;
					        TIM2_CH2_CAPTURE_MODE = 1;
									TIM_SetCounter(TIM2,0x0);
					        TIM_OC2PolarityConfig(TIM2,TIM_ICPolarity_Falling);  //TIM_ICPolarity_Falling
					        break;					
					case 1: 
						      TIM2_CH2_CAPTURE_H = TIM_GetCounter(TIM2);
					        TIM2_CH2_CAPTURE_MODE = 2;
					        TIM_OC2PolarityConfig(TIM2,TIM_ICPolarity_Rising);
					        break;
					case 2:
						     TIM2_CH2_CAPTURE_HL = TIM_GetCounter(TIM2);
					       TIM2_CH2_CAPTURE_MODE = 3;
					       TIM_OC2PolarityConfig(TIM2,TIM_ICPolarity_Rising);
					        break;
          default: break;					
				}
		}
		else
		{
			TIM2_CH2_CAPTURE_MODE = 0;		
		}
	}

	if(TIM_GetITStatus(TIM2,TIM_IT_CC3) == 1)
	{
		TIM_ClearITPendingBit(TIM2,TIM_IT_CC3);
		if(!CAPTURE_Flag)
		{
				switch(TIM2_CH3_CAPTURE_MODE)
				{
					case 0: 
						      TIM2_CH3_CAPTURE_HL = 0;
					        TIM2_CH3_CAPTURE_H = 0;
					        TIM2_CH3_CAPTURE_MODE = 1;
									TIM_SetCounter(TIM2,0x0);
					        TIM_OC3PolarityConfig(TIM2,TIM_ICPolarity_Falling);  //TIM_ICPolarity_Falling
					        break;
					
					case 1: 
						      TIM2_CH3_CAPTURE_H = TIM_GetCounter(TIM2);
					        TIM2_CH3_CAPTURE_MODE = 2;
					        TIM_OC3PolarityConfig(TIM2,TIM_ICPolarity_Rising);
					        break;
					case 2:
						     TIM2_CH3_CAPTURE_HL = TIM_GetCounter(TIM2);
					       TIM2_CH3_CAPTURE_MODE = 3;
					       TIM_OC3PolarityConfig(TIM2,TIM_ICPolarity_Rising);
					        break;
          default: break;					
				}
		}
		else
		{
			TIM2_CH3_CAPTURE_MODE = 0;		
		}
	}	
}


/****************输出PWM比较中断函数***************/
void TIM3_IRQHandler(void)
{
	if(TIM_GetITStatus(TIM3,TIM_IT_CC1) == 1)
	{	
		TIM_ClearITPendingBit(TIM3,TIM_IT_CC1);
		capture = TIM_GetCapture1(TIM3);
		TIM_SetCompare1(TIM3,capture + TIM3_Ch1_Val *1/2);	
	}
	
  if(TIM_GetITStatus(TIM3,TIM_IT_CC2) == 1)
	{	
		TIM_ClearITPendingBit(TIM3,TIM_IT_CC2);
		capture = TIM_GetCapture2(TIM3);
		TIM_SetCompare2(TIM3,capture + TIM3_Ch2_Val *1/2);		
	}
}

/****************USART2通信中断***************/
void USART2_IRQHandler(void)
{
	u8 temp;
	if(USART_GetFlagStatus(USART2, USART_IT_RXNE) == SET)
	{
		USART_ClearITPendingBit(USART2,USART_IT_RXNE);
		temp = USART_ReceiveData(USART2);
		if((temp == '\n') || (RXCOUNT == 20))//回车换行
		{
			count = RXCOUNT-1;
//			RXBUF[RXCOUNT-1] = 0;  //避免\r显示在LCD发生的乱码
			RXCOUNT =0;
			RXOVER = 1;
			USART_ITConfig(USART2,USART_IT_RXNE,DISABLE);
		}
		else 
		{ 
			RXBUF[RXCOUNT] = temp;
		  RXCOUNT++;		
		}
	}
}

逻辑分析仪结果如下:杜邦线连接PA1/PA2 ----PA7 / PA6即可观察输入频率
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200221135257339.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIzNjMwMg==,size_16,color_FFFFFF,t_70)
输入捕获主要借鉴大佬的思想
[详细可见](https://blog.csdn.net/qq_34952376/article/details/81172774)
*wj
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
蓝桥杯嵌入式国赛 第五届 代码 双通道方波频率检测与倍频
06-05
蓝桥杯嵌入式国赛 第五届 实现代码 双通道方波频率检测与倍频
80、基于STM32单片机数字频率计频率检测配NE555脉冲发生器设计 (程序+原理图+PCB源文件+参考论文+硬件设计资料+元器件清单等)
2301_78172491的博客
08-21 270
4、按键有设置按键、设置+、设置-，在设置情况下可以对设置值进行加减运算，设置值同样两种自动切换显示，低于1000时直接显示，高于1000时显示单位k，方便查看对比。3、当前频率值显示分两种，低于1000hz时显示单位为hz，高于1000hz时显示单位kHz，自动切换，方便查看。2、通过液晶LCD1602液晶实时显示当前频率值以及设置值，如果当前频率值超过设置阈值，蜂鸣器进行报警。1、单片机实时采集脉冲发送过来的脉冲数，在单位时间内的脉冲数也就是频率值。本项目包含的所有文件都可以点击下面的名片，发送 “
90、基于STM32单片机数字频率计频率检测配NE555脉冲发生器设计(程序+原理图+PCB源文件+参考论文+硬件设计资料+元器件清单等)
ENGLISH_HHZ的专栏
07-05 1281
STM32系列是为要求高性能、低成本、低功耗的嵌入式应用专门设计的ARM Cortex-M3内核。按性能分成两个不同的系列：“增强型”STM32F103系列和“基本型”STM32F101系列。增强型系列的时钟频率能达到72MHz，是同类产品中频率最高的；基本型的时钟频率为36MHz，用16位产品一样的价格得到比16位产品更大的性能，是16位产品的最好选择。两个系列都有内置的32K到128K的闪存，不同的是SRAM的最大容量和外设接口的组合。
STM32单片机（一）STM32简介
AnChenliang_1002的博客
05-23 2万+
本节是STM32单片机部分的第一节，主要对STM32部分课程进行简单介绍，以及对STM32单片机进行简单介绍；其中包括STM32介绍、ARM介绍、片上资源/外设、命名规则、系统结构、引脚定义、启动配置、最小系统电路等。
蓝桥杯嵌入式——第五届省赛-双通道方波频率检测与倍频输出
FILWY_M
03-03 1280
蓝桥杯嵌入式——第五届省赛-双通道方波频率检测与倍频输出 这里写目录标题蓝桥杯嵌入式——第五届省赛-双通道方波频率检测与倍频输出一、赛题分析二、问题总结三、代码 一、赛题分析 这一届的赛题涉及到的模块有LED、LCD、按键、输入捕获、PWM输出、定时器、EEPROM、串口通信等。其中大部分的内容都是比较常规的，需要注意的就是输入捕获，如何同时捕获两路的PWM信号，这个在我的一篇博客中有写到，https://blog.csdn.net/qq_43715171/article/details/113854043
蓝桥杯嵌入式开发经验分享（第六届模拟——“双通道方波频率检测与倍频输出”）
eavan的博客
02-23 3990
作者：马一飞                                                         QQ：791729359        在学习过程中有什么问题可以联系 （本篇博客有很多还没讲解很细致，先贴出代码，等有时间再进行注解） 一、题目         “双通道方波频率检测与倍频输出”设计要求测量输入方波信号的频率，并根据设定的倍频数，输出经过倍频的方波...
蓝桥嵌入式之 2015_第六届_蓝桥杯_省赛_双通道方波 频率检测与倍频 输出
悟已往之不谏 知来者之可追
03-04 1458
工程可见Github&amp;amp;lt;传送门&amp;amp;gt; 代码较多，这里仅贴出写的过程中的问题。 输入通道 PA1-TIM2_CH2 对应输出 PA6-TIM3_CH1 输入通道 PA2-TIM2_CH3 对应输出 PA7_TIM3_CH2 代码算是可以实现题目里面要求的功能，但是还有两个地方没弄明白。 1、PWM输出的瑕疵 原因待查找… 2、串口的问题 PA1 PA2作输入捕获，一旦有外部信号输入，在开...
蓝桥杯嵌入式-双通道方波频率检测与倍频输出
weixin_43636084的博客
04-02 768
一，自己觉得此题需要注意的 1、 本题需用到PA2的串口发送和TIM2_CH3的捕获功能，如果不加处理，会发生冲突，这里我选择把PA2串口部分初始化注销掉 //RXD-PA3 设置为浮空模式 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPI...
蓝桥杯第五届嵌入式程序
qqGHJ的博客
02-28 971
本届试题主要考察PWM的捕获与输出；难度较大； ①、库文件 ②、中断服务函数 u8 flag=0,count=0; void USART2_IRQHandler(void) { u8 temp; if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) { USART_ClearITPendingBit(USART...
蓝桥杯嵌入式类比赛经验分享
热门推荐
结庐为家的博客
11-25 3万+
第八届蓝桥杯大赛(嵌入式组) 蓝桥杯的嵌入式组是Stm32rbt6单片机的编程比赛，我想对于学习电子信息工程专业的同学这不是一个陌生的名词，如果你是电信专业的大四同学却没有听说过msp430或者stm32，或许你应该审视一下自己是否懈怠了4年时光，不过一般大四的同学是看不见我这篇文章的。 看到这篇文章的人大多是要参加这个比赛的同学，我在上次比赛中只获得了国二，差一丢丢国一这是非常令人遗憾
“ 蓝桥 杯”第六届全国软件和信息技术专业人才大赛嵌入式设计与开发项目模拟——双通道方波频率检测与倍频输出·代码.zip
01-16
练习蓝桥杯历年赛题和模拟题，积累学习经验，掌握自己的学习方式和构码能力，提高编程能力。 “ 蓝桥 杯”第六届全国软件和信息技术专业人才大赛嵌入式设计与开发项目模拟——双通道方波频率检测与倍频输出·代码
2015_第六届_蓝桥杯_省赛_双通道方波 频率检测与倍频 输出.rar
09-06
2015_第六届_蓝桥杯_省赛_双通道方波 频率检测与倍频 输出 “双通道方波频率检测与倍频输出”设计要求测量输入方波信号的频率，并根据设定的 倍频数，输出经过倍频的方波信号。倍频数可以通过按键设定，也可以通过串行口设定；LCD 显示 2 个通道的频率测量值和倍频数
蓝桥杯嵌入式第六届模拟题及答案
03-08
蓝桥杯嵌入式第六届模拟题及答案， 功能简述 “双通道方波频率检测与倍频输出” 设计要求测量输入方波信号的频率，并根据设定的 倍频数， 输出经过倍频的方波信号。倍频数可以通过按键设定，也可以通过串行口设定； LCD 显示 2 个通道的频率测量值和倍频数
6.第六届双通道方波 频率检测与倍频输出.rar
08-06
大学生蓝桥杯嵌入式的第六届双通道方波频率检测与倍频输出题，参考代码，自己编写的代码，包含试题。
蓝桥杯官网练习题和测评数据-算法提高129-172(共44题)
04-15
蓝桥杯练习题概览 试题集名称 试题总数 更新时间 入门训练 4 2013/10/9 基础练习 30 2013/11/3 算法训练 180 2018-03-09 算法提高 220 2018-03-09 历届试题 55 2017-12-18 包括题目和测试数据
蓝桥杯嵌入式第五届省赛_双通道方波频率检测与倍频输出_工程代码
05-20
蓝桥杯嵌入式第五届省赛_双通道方波频率检测与倍频输出_工程代码，已实现题目所有要求，打开直接运行即可，压缩包内是完整的工程文件，希望能够帮助到大家。
第五届省赛-双通道方波频率检测与倍频输出1
08-04
1. 频率测量和倍频输出 2. 按键功能 3. LED 指示功能 5. LCD 显示单元 6. 串行设定功能 7. 电路设计 1. 实现双通道输入信号频率测量功
第五届省赛-双通道方波频率检测与倍频输出.pdf
04-04
第五届省赛-双通道方波频率检测与倍频输出
STM32初学入门笔记（2）：STM32CubeMX配置STM32输出可调PWM方波
m0_73677866的博客
07-06 7723
PWM是一种应用广泛的利用微处理器的数字输出来对模拟电路进行控制的一种技术（即对脉冲宽度的控制）PWM同时也是驱动蜂鸣器，驱动舵机，通信等重要的一环，而对于初学者而言，点完灯的下一个程序就是驱动蜂鸣器，本篇将讲述如何使用及调整PWM输出频率，占空比
蓝桥杯嵌入式第十二届省赛
最新发布
02-01
蓝桥杯嵌入式第十二届省赛是蓝桥杯全国软件和信息技术专业人才大赛的一个分赛项，专门针对嵌入式系统开发领域的比赛。该比赛旨在培养和选拔嵌入式系统开发领域的优秀人才，提高学生在嵌入式系统设计与开发方面的综合能力。 比赛内容主要包括两个部分：理论考试和实践操作。理论考试主要测试参赛选手对嵌入式系统开发相关知识的掌握程度，包括嵌入式系统基础知识、C语言编程、硬件电路设计等方面。实践操作则要求选手根据题目要求，使用指定的开发板和软件工具进行嵌入式系统的设计与开发，完成相应的任务。 蓝桥杯嵌入式第十二届省赛是一个具有挑战性和实践性的比赛，参赛选手需要具备扎实的嵌入式系统开发基础知识和编程技能，同时还需要具备良好的团队合作能力和解决问题的能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值