蓝桥杯第九届嵌入式程序

最新推荐文章于 2025-02-09 10:07:36 发布
最新推荐文章于 2025-02-09 10:07:36 发布
阅读量1.1k 收藏 11
点赞数 3
分类专栏： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qqGHJ/article/details/88716442
版权

本届试题看似简单，实则暗藏杀机，相比往年的题目，近两年来嵌入式难度有所提高，虽说考的模块不算多，但无疑增加了考察的灵活度，本届赛题即是典型，比如考察按键的长短按测量，我们需要检测按键按下的时间......

main.c

#include "key.h"
#include "led.h"
#include "lcd.h"
#include "stdio.h"
#include "at24c02.h"
#include "tim.h"

unsigned char ucNo = 1, ucLed = 1;
unsigned char ucState, ucStr[21];
unsigned char ucHour, ucMin, ucSec, ucKey_Long;
unsigned long ulTick_ms, ulSec, ulKey_Time;

void KEY_Proc(void);
void LCD_Proc(void);
void B3_Proc(void);

int main(void)
{
  SysTick_Config(72000);
  KEY_Init();
  LED_Init();

  STM3210B_LCD_Init();
  LCD_Clear(Blue);
  LCD_SetBackColor(Blue);
  LCD_SetTextColor(White);

  i2c_init();
  TIM3_OCInit_7591();
	
  i2c_read(ucStr, 0, 3);
  ucHour = ucStr[0];
	ucMin = ucStr[1];
	ucSec = ucStr[2];
	if(ucHour > 24) ucHour = 0;
  if(ucMin > 60) ucMin = 0;
  if(ucSec > 60) ucSec = 0;
	
  while(1)
  {
    KEY_Proc();
    LCD_Proc();
  }
}

void KEY_Proc(void)
{
  unsigned char ucKey_Val;

  ucKey_Val = KEY_Scan();
  switch(ucKey_Val)
  {
    case 1:							// B1: ???????
      if(!ucState)
      {
        if(++ucNo == 6)
          ucNo = 1;
        i2c_read(ucStr, 3*(ucNo-1), 3);
        ucHour = ucStr[0];
        ucMin  = ucStr[1];
        ucSec  = ucStr[2];
      }
      break;
    case 2:							// B2: ???????
      if(!ucState)
        ucState = 1;
      else 
        if(++ucState == 4)
          ucState = 1;
      break;
    case 3:							// B3: ???
      B3_Proc();
      break;
    case 4:							// B4: ???
      if(!ucState)
      {
        i2c_read(ucStr, 3*(ucNo-1), 3);
        ucHour = ucStr[0];
        ucMin  = ucStr[1];
        ucSec  = ucStr[2];
      }
      if(ucState < 4)
        ulSec = (long)ucHour*3600 + ucMin*60 + ucSec;
      if(ucState != 4)
      {
				TIM_CCxCmd(TIM3, TIM_Channel_1, ENABLE);
        ucState = 4;
			}
      else
        ucState = 5;
  }

  if(ulTick_ms-ulKey_Time > 800)
  {
    switch(ucKey_Long)
    {
      case 2:
        if(ucState == 1 || ucState == 2 || ucState == 3)
        {
          ucStr[0] = ucHour;
          ucStr[1] = ucMin;
          ucStr[2] = ucSec;
          i2c_write(ucStr, 3*(ucNo - 1), 3);
 
          ucState = 0;
        }
	    break;
      case 3:
        B3_Proc();
        break;
      case 4:
        if(ucState == 4 || ucState == 5)
          ucState = 0;
    }
  }
}

void B3_Proc(void)
{
  switch(ucState)
  {
    case 1:
      if(++ucHour > 23)
        ucHour = 0;
      break;
    case 2:
      if(++ucMin > 59)
        ucMin = 0;
      break;
    case 3:
      if(++ucSec > 59)
        ucSec = 0;
  }
}

void LCD_Proc(void)
{
  sprintf((char*)ucStr, "        No.%1u", ucNo);
  LCD_DisplayStringLine(Line3, ucStr);

  if(ucState == 1) LCD_SetBackColor(Red);
  LCD_DisplayChar(Line5, 224, ucHour/10+0x30);
  LCD_DisplayChar(Line5, 208, ucHour%10+0x30);
  LCD_SetBackColor(Blue);
  LCD_DisplayChar(Line5, 192, ':');

  if(ucState == 2) LCD_SetBackColor(Red);
  LCD_DisplayChar(Line5, 176, ucMin/10+0x30);
  LCD_DisplayChar(Line5, 160, ucMin%10+0x30);
  LCD_SetBackColor(Blue);
  LCD_DisplayChar(Line5, 144, ':');

  if(ucState == 3) LCD_SetBackColor(Red);
  LCD_DisplayChar(Line5, 128, ucSec/10+0x30);
  LCD_DisplayChar(Line5, 112, ucSec%10+0x30);
  LCD_SetBackColor(Blue);

  switch(ucState)
  {
    case 0:
      sprintf((char*)ucStr, "      Standby.");
      break;
    case 1:
    case 2:
    case 3:
      sprintf((char*)ucStr, "      Setting.");
      break;
    case 4:
      sprintf((char*)ucStr, "      Running.");
      break;
    case 5:
      sprintf((char*)ucStr, "       Pause. ");
  }
  LCD_DisplayStringLine(Line7, ucStr);
}
//SysTick??????????:
void SysTick_Handler(void)
{
  ulTick_ms++;

  if(ucState == 4)
  {
    if(ulTick_ms%500 == 0)
    {
      ucLed ^= 1;
      LED_Disp(ucLed);
    }
    if(ulTick_ms%1000 == 0)
    {
      if(ulSec--)
      {
        ucHour = ulSec / 3600;
        ucMin  = ulSec % 3600 / 60;
        ucSec  = ulSec % 3600 % 60;
      }
      else
        ucState = 0;
    }
  }
  else
  {
    TIM_CCxCmd(TIM3, TIM_Channel_1, DISABLE);
    LED_Disp(0);
  }
}

key.c

#include "key.h"
// KEY接口初始化
void KEY_Init(void)
{
//GPIO_InitTypeDef GPIO_InitStructure;
  // 允许GPIOA和GPIOB时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  /* PA0和PA8浮空输入(复位状态，可以省略)
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure); */
  /* PB1和PB2浮空输入(复位状态，可以省略)
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOB, &GPIO_InitStructure); */
}
// KEY扫描
unsigned char KEY_Scan(void)
{
  unsigned char ucKey_Val = 0;
  // 判断B1和B2是否按下
  if(~GPIO_ReadInputData(GPIOA) & 0x101)
  {
    Delay_KEY(10); // 延时10ms消抖
    if(!GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0))
      ucKey_Val = 1;
    if(!GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8))
      ucKey_Val = 2;
	}
  // 判断B3和B4是否按下
  else if(~GPIO_ReadInputData(GPIOB) & 6)
  {
    Delay_KEY(10);		// 延时10ms消抖
    if(!GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1))
      ucKey_Val = 3;
    if(!GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2))
      ucKey_Val = 4;
  }
  if(ucKey_Val != ucKey_Long)
	{
    ucKey_Long = ucKey_Val;
    ulKey_Time = ulTick_ms;
    return ucKey_Val;
	}
  return 0;
}

void Delay_KEY(unsigned int ms)
{
  unsigned int i, j;

  for(i=0; i<ms; i++)
    for(j=0; j<7992; j++);			// SYSCLK = 72MHz
//  for(j=0; j<1598; j++);			// SYSCLK = 8MHz
}

at24c02.c(EEPROM)

/*
  程序说明: CT117E嵌入式竞赛板GPIO模拟I2C总线驱动程序
  软件环境: Keil uVision 4.10 
  硬件环境: CT117E嵌入式竞赛板
  日    期: 2011-8-9
*/

#include "stm32f10x.h"

/** I2C 总线接口 */
#define I2C_PORT GPIOB
#define SDA_Pin	GPIO_Pin_7
#define SCL_Pin GPIO_Pin_6

#define FAILURE 0
#define SUCCESS 1

//配置SDA信号线为输入模式
void SDA_Input_Mode()
{
	GPIO_InitTypeDef GPIO_InitStructure;

	GPIO_InitStructure.GPIO_Pin = SDA_Pin;
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;	 

  	GPIO_Init(I2C_PORT, &GPIO_InitStructure);
}

//配置SDA信号线为输出模式
void SDA_Output_Mode()
{
	GPIO_InitTypeDef GPIO_InitStructure;

	GPIO_InitStructure.GPIO_Pin = SDA_Pin;
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

  	GPIO_Init(I2C_PORT, &GPIO_InitStructure);
}

//
void SDA_Output( uint16_t val )
{
	if ( val ) {
		GPIO_SetBits(I2C_PORT,SDA_Pin);
	} else {
		GPIO_ResetBits(I2C_PORT,SDA_Pin);
	}
}

//
void SCL_Output( uint16_t val )
{
	if ( val ) {
		GPIO_SetBits(I2C_PORT,SCL_Pin);
	} else {
		GPIO_ResetBits(I2C_PORT,SCL_Pin);
	}
}

//
uint8_t SDA_Input()
{
	return GPIO_ReadInputDataBit( I2C_PORT, SDA_Pin);
}

//延时程序
void delay1(unsigned int n)
{
	unsigned int i;
	for ( i=0;i<n;++i);
}

//I2C总线启动
void I2CStart(void)
{
	SDA_Output(1); delay1(500);
	SCL_Output(1); delay1(500);
	SDA_Output(0); delay1(500);
	SCL_Output(0); delay1(500);
}

//I2C总线停止
void I2CStop(void)
{
	SCL_Output(0); delay1(500);
	SDA_Output(0); delay1(500);
	SCL_Output(1); delay1(500);
	SDA_Output(1); delay1(500);

}

//等待应答
unsigned char I2CWaitAck(void)
{
	unsigned short cErrTime = 5;
	SDA_Input_Mode();	delay1(500);
	SCL_Output(1); delay1(500);
	while(SDA_Input())
	{
		cErrTime--;
		delay1(500);
		if (0 == cErrTime)
		{
			SDA_Output_Mode();
			I2CStop();
			return FAILURE;
		}
	}
	SDA_Output_Mode();
	SCL_Output(0); delay1(500); 
	return SUCCESS;
}

//发送应答位
void I2CSendAck(void)
{
	SDA_Output(0); delay1(500);
	SCL_Output(1); delay1(500);
	SCL_Output(0); delay1(500);
}

//
void I2CSendNotAck(void)
{
	SDA_Output(1); delay1(500);
	SCL_Output(1); delay1(500);
	SCL_Output(0); delay1(500);
}

//通过I2C总线发送一个字节数据
void I2CSendByte(unsigned char cSendByte)
{
	unsigned char  i = 8;
	while (i--)
	{
		SCL_Output(0); delay1(500); 
		SDA_Output(cSendByte & 0x80); delay1(500);
		cSendByte += cSendByte;
		SCL_Output(1);delay1(500); 
	}
	SCL_Output(0); delay1(500); 
}

//从I2C总线接收一个字节数据
unsigned char I2CReceiveByte(void)
{
	unsigned char i = 8;
	unsigned char cR_Byte = 0;
	SDA_Input_Mode(); 
	while (i--)
	{
		cR_Byte += cR_Byte;
		SCL_Output(0); delay1(500); 
		SCL_Output(1); delay1(500); 
		cR_Byte |=  SDA_Input(); 
	}
	SCL_Output(0); delay1(500); 
	SDA_Output_Mode();
	return cR_Byte;
}

//I2C总线初始化
void i2c_init()
{
	GPIO_InitTypeDef GPIO_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

	GPIO_InitStructure.GPIO_Pin = SDA_Pin | SCL_Pin;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 // **

	GPIO_Init(I2C_PORT, &GPIO_InitStructure);
}
// AT24C02???
void i2c_read(unsigned char* pucBuf, unsigned char ucAddr,
  unsigned char ucNum)
{
  I2CStart(); 
  I2CSendByte(0xa0);
  I2CWaitAck(); 

  I2CSendByte(ucAddr);
  I2CWaitAck(); 
	
  I2CStart();
  I2CSendByte(0xa1); 
  I2CWaitAck();

  while(ucNum--)
  {
    *pucBuf++ = I2CReceiveByte();
    if(ucNum)
      I2CSendAck();
    else
      I2CSendNotAck();
  }
  I2CStop();
}
// AT24C02???
void i2c_write(unsigned char* pucBuf, unsigned char ucAddr,
  unsigned char ucNum)
{
  I2CStart(); 
  I2CSendByte(0xa0); 
  I2CWaitAck(); 

  I2CSendByte(ucAddr);	
  I2CWaitAck();

  while(ucNum--)
  {
    I2CSendByte(*pucBuf++); 
    I2CWaitAck(); 
  }
  I2CStop();
  delay1(500);
}

tim.c

#include "tim.h"
// TIM1??2(PA9)???????????
void TIM1_OCInit(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_OCInitTypeDef	TIM_OCInitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
	
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 999;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInitStruct.TIM_RepetitionCounter = 0;
  TIM_TimeBaseInit(TIM1, &TIM_TimeBaseInitStruct);
	
  TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStruct.TIM_OutputNState = TIM_OutputNState_Disable;
  TIM_OCInitStruct.TIM_Pulse = 250;	
  TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC2Init(TIM1, &TIM_OCInitStruct);	
	
  TIM_CtrlPWMOutputs(TIM1, ENABLE);
  TIM_Cmd(TIM1, ENABLE);
}
// TIM2??2(PA1)??????????????????
void TIM2_ICInit(void)
{
//GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_ICInitTypeDef	TIM_ICInitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  /*
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStruct);
  */
  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 65535;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);

  TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
  TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStruct.TIM_ICFilter = 0;
  TIM_PWMIConfig(TIM2, &TIM_ICInitStruct);
	
  TIM_SelectInputTrigger(TIM2, TIM_TS_TI2FP2);
  TIM_SelectSlaveMode(TIM2, TIM_SlaveMode_Reset);
  TIM_Cmd(TIM2, ENABLE);
}
// TIM2????????????????
unsigned char TIM2_Cap(unsigned int* puiTim_Val)
{
  if(TIM_GetFlagStatus(TIM2, TIM_FLAG_CC2))
  {
    puiTim_Val[0] = TIM_GetCapture2(TIM2)+1;
    puiTim_Val[1] = TIM_GetCapture1(TIM2)+1;
    return 1;
  }
  return 0;
}

void TIM2_OCInit_7272(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_OCInitTypeDef	TIM_OCInitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 999;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInitStruct.TIM_RepetitionCounter = 0;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);

  TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStruct.TIM_Pulse = 500;	
  TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC2Init(TIM2, &TIM_OCInitStruct);	

  TIM_Cmd(TIM2, ENABLE);
}

void TIM3_ICInit_7272(void)
{
//GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_ICInitTypeDef	TIM_ICInitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  /*
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStruct);
  */
  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 65535;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);

  TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
  TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStruct.TIM_ICFilter = 0;
  TIM_ICInit(TIM3, &TIM_ICInitStruct);

  TIM_SelectInputTrigger(TIM3, TIM_TS_TI2FP2);
  TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Reset);
  TIM_Cmd(TIM3, ENABLE);
}
// TIM3????????????????
unsigned int TIM3_Cap(void)
{
  if(TIM_GetFlagStatus(TIM3, TIM_FLAG_CC2))
    return TIM_GetCapture2(TIM3)+1;
  else
    return 0;
}

void TIM3_OCInit_7381(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_OCInitTypeDef	TIM_OCInitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 999;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInitStruct.TIM_RepetitionCounter = 0;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);

  TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Disable;
  TIM_OCInitStruct.TIM_Pulse = 500;
  TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC1Init(TIM3, &TIM_OCInitStruct);	 
  TIM_OC2Init(TIM3, &TIM_OCInitStruct);	

  TIM_Cmd(TIM3, ENABLE);
}

void TIM2_ICInit_7482(void)
{
//GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_ICInitTypeDef	TIM_ICInitStruct;
//NVIC_InitTypeDef NVIC_InitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  /*
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStruct);
  */
  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 65535;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);

  TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
  TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStruct.TIM_ICFilter = 0;
  TIM_ICInit(TIM2, &TIM_ICInitStruct);

  TIM_ICInitStruct.TIM_Channel = TIM_Channel_3;
  TIM_ICInit(TIM2, &TIM_ICInitStruct);
	
  TIM_Cmd(TIM2, ENABLE);
/*?????
  TIM_ITConfig(TIM2, TIM_IT_CC2 | TIM_IT_CC3, ENABLE);	
  NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
  NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStruct);*/ 
}

void TIM3_OCInit_7482(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_OCInitTypeDef	TIM_OCInitStruct;
//NVIC_InitTypeDef NVIC_InitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);	

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitStruct.TIM_Period = 65535;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;	
  TIM_TimeBaseInitStruct.TIM_RepetitionCounter = 0;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);	

  TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_Toggle;
  TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStruct.TIM_Pulse = 1600;
  TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC1Init(TIM3, &TIM_OCInitStruct);	 
  TIM_OC2Init(TIM3, &TIM_OCInitStruct);	

  TIM_Cmd(TIM3, ENABLE);
/*?????
  TIM_ITConfig(TIM3, TIM_IT_CC1 | TIM_IT_CC2, ENABLE);	
  NVIC_InitStruct.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStruct);*/ 
}

void TIM3_OCInit_7591(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
  TIM_OCInitTypeDef	TIM_OCInitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStruct);

  TIM_TimeBaseInitStruct.TIM_Prescaler = 71;
  TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;	
  TIM_TimeBaseInitStruct.TIM_Period = 999;
  TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;	
  TIM_TimeBaseInitStruct.TIM_RepetitionCounter = 0;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);	

  TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Disable;
  TIM_OCInitStruct.TIM_Pulse = 800;
  TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC1Init(TIM3, &TIM_OCInitStruct);	

  TIM_Cmd(TIM3, ENABLE);
}

中断服务函数

static unsigned char ms2 = 0;
static unsigned char ms3 = 3;
unsigned char switch_led = 0;

extern unsigned char ledFlag;
extern unsigned char ledEnable;

//
void SysTick_Handler(void)
{
	TimingDelay--;
	

	if(++ms3 == 200){
		ms3 = 0;
		switch_led = ~switch_led;
	}
	
	if(++ms2 == 10){
		ms2 = 0;
		Key_Scan();
	}
}


extern unsigned char TimeDisplay;

void RTC_IRQHandler(void)
{
	if (RTC_GetITStatus(RTC_IT_SEC) != RESET){
		
		TimeDisplay = 1;	//显示更新标志
		
		RTC_ClearITPendingBit(RTC_IT_SEC);
	}
}
/**
  * @brief  This function handles PPP interrupt request.
  * @param  None
  * @retval None
  */

char rx_buff[20];
char rx_counter = 0;
char rx_over = 0;

void USART2_IRQHandler(void)
{
	
	if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET){
		
		USART_ClearITPendingBit(USART2,USART_IT_RXNE);

		rx_buff[rx_counter] = USART_ReceiveData(USART2);
		if((rx_counter == 19) || (rx_buff[rx_counter] == '\n')){
			rx_over = 1;
			rx_counter = 0;
		}
		else{
			rx_counter++;
		}
	}		
}

完整代码

蓝桥杯第九届-省赛-2018年嵌入式试题.rar
08-19
蓝桥杯第九届 省赛 嵌入式试题资料。 包含试题、模板和各类工具软件。
备战蓝桥杯（4）——第九届蓝桥杯嵌入式省赛赛题实战
SUPPER__xxh的博客
03-08 6083
这次第九届蓝桥杯的省赛的题比第八届省赛的题简单了，但是我在做的时候也有很多小问题导致卡壳，也是将之前学习过的东西在做了一次小复习，同时这次省赛的长短按键也是比第一次接触到，很有收获。本次仍然是基于CT117E-M4平台，用的CUBEMX与keil开发。
GPIO函数详解（二）
最新发布
ElePower9527的博客
02-09 1159
用于读取指定 GPIO 端口的所有引脚的电平状态（16 位值，每位对应一个引脚）。用于读取指定 GPIO 端口的所有引脚的输出状态（16 位值，每位对应一个引脚）。返回值是一个 16 位的值，每位对应一个引脚的状态。该函数仅适用于配置为输出模式的 GPIO 引脚（如推挽输出、开漏输出）。该函数仅适用于配置为输出模式的 GPIO 引脚（如推挽输出、开漏输出）。该函数读取的是输出数据寄存器（ODR）的值，而不是实际引脚的电平状态。该函数读取的是输出数据寄存器（ODR）的值，而不是实际引脚的电平状态。
STM32HAL库【G431】--【蓝桥杯嵌入式第九届省赛题】
Elsaaaaaaa的博客
12-28 1421
STM32，STM32cudemx，蓝桥杯，第九届省赛，完整工程文件，HAL库，嵌入式
蓝桥杯嵌入式STM32G431——第九届省赛真题电子定时器
qq_52542756的博客
02-16 2466
第九届省赛真题电子定时器第九届省赛真题主函数代码(不包含各模块初始化代码）按键模块与LCD模块的逻辑图(仅供参考） 第九届省赛真题 主函数代码(不包含各模块初始化代码） #include "main.h" #include "rcc.h" #include "led_key.h" #include "lcd.h" #include "tim.h" #include "i2c.h" //***通过滴答定时器实现执行速度控制变量 __IO uint32_t uwTick_LED_Speed_Ctrl; _
蓝桥杯嵌入式第九届省赛真题
qq_51663309的博客
11-29 3009
蓝桥杯第九届省赛真题 文章目录蓝桥杯第九届省赛真题1.题目2.题目分析3.项目结构3.1 函数结构与全局变量3.2 倒计时基础实现3.3 方便的状态控制函数3.4 按键总控结构3.5 KEY2的设置功能3.6 KEY3的设置时间功能3.7 KEY4的状态设置功能3.8 存储部分3.9 主函数 1.题目 1、LCD 显示 ​ LCD 显示存储位置、定时时间和当前状态。系统预留 5 个存储位置用于存储常用的定时时间。当定时器停止时，当前状态为 Standby；当系统正在设置时间时，当前状态为 Setting；当
【蓝桥杯嵌入式】第十一届蓝桥杯嵌入式国赛程序设计题
03-04
【蓝桥杯嵌入式】第十一届蓝桥杯嵌入式国赛程序设计题是针对嵌入式系统开发的一项专业竞赛，旨在检验参赛者的编程技能、硬件理解以及实际问题解决能力。作为一项全国性的赛事，它对于学习和提升嵌入式领域的知识具有...
蓝桥杯嵌入式第十届省赛赛题
07-27
【蓝桥杯嵌入式第十届省赛赛题】是一个针对嵌入式系统设计与开发的比赛，旨在检验参赛者的编程技能、硬件理解能力和问题解决能力。蓝桥杯比赛是全国范围内颇具影响力的一项IT竞赛，尤其在软件和电子工程领域。嵌入式...
蓝桥杯嵌入式第九届省赛程序设计题（完整工程+题目）（0积分，拿走请点赞）
05-27
【标题】中的“蓝桥杯嵌入式第九届省赛程序设计题”指的是一个与嵌入式系统开发相关的竞赛，名为“蓝桥杯”。蓝桥杯是中国一项知名的计算机软件和电子设计竞赛，旨在促进信息技术和电子科技的发展，提高学生的创新...
第十四届蓝桥杯嵌入式国赛
06-03
在“第十四届蓝桥杯嵌入式国赛”中，参赛者们将面临的是对这种技术的深入理解和应用挑战。 嵌入式系统的构成主要包括硬件和软件两部分。硬件方面，它通常由微处理器、存储器（包括ROM和RAM）、输入/输出接口、电源...
蓝桥杯第五届嵌入式题目一代码
03-25
在第五届蓝桥杯嵌入式比赛中，"test_050(050)"可能是一个具体的挑战题目，涉及到实际的代码实现。这个题目可能是要求参赛者设计并实现一个特定功能的嵌入式程序，比如设备控制、数据采集、实时处理等。对于这样的...
蓝桥杯第9届省赛源代码+试题有注释
02-01
我所写的第9届蓝桥杯省赛试题的源代码，经过不断完善一已经没有任何问题，里面有一系列的注释，可以帮助大家很好的学习51单片机。
蓝桥杯嵌入式比赛-经验分享视频（第九届）.rar
01-16
蓝桥杯嵌入式比赛-经验分享视频（第九届）
蓝桥杯省赛第九届真题（程序题答案）
04-17
蓝桥杯省赛第九届真题（程序题答案），功能已全部实现，都是用比较简单的方法编写的，适合初学者，最关键的莫过于i2c的存储和时钟，都已经写全，欢迎大家提出自己的看法。
蓝桥杯CT117E嵌入式竞赛板省赛第九届代码
12-02
蓝桥杯嵌入式组省赛代码，第九届代码，功能完全实现，文件内附带题目。“模拟升降控制器” 蓝桥杯嵌入式组省赛代码，第九届代码，功能完全实现，文件内附带题目。“模拟升降控制器”
STM32的GPIO输入-(软件延时方式)(库函数)
11-28
STM32的GPIO输入-(软件延时方式)(库函数)，亲测可用，内有详细代码注释和说明讲解，很好的学习资料。
2018第九届蓝桥省赛题目
qq_41818544的博客
03-22 325
标题：第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 该题很简单：125 标题：明码 汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。 16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。 一个字节可以存储8位信息，用3...
【STM32G431RBTx】备战蓝桥杯嵌入式→省赛试题→第九届
qq_66792436的博客
01-24 849
蓝桥杯
免费资源 蓝桥杯比赛 历届省赛题目解答——第九届（省一代码加注释）
自由学者亻伊宸的博客
03-01 4125
蓝桥杯比赛 单片机组 第九届省赛题目解答（代码加注释）一、题目二、hex文件三、主函数实现四、整个工程文件最后   一、题目   历届的省赛和国赛的题目我已经在前面的文章（点击查看）里给大家分享了（网盘资源），需要的话，直接去下载，我在这里就不再赘述了。 二、hex文件 读者下载这个文件然后用烧录软件直接烧入单片机就可以用了！ 链接：https://pan.baidu.com/s/1msXP3g9RfTRvvAbicNgG9w 提取码：52sv 三、主函数实现   提示：比赛过程中，仅仅主函数修改可能
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

身在江湖的郭大侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值