蓝桥杯嵌入式第五届省赛代码

//这届的题目是有问题的
#include "stm32f10x.h"
#include "lcd.h"
#include "led.h"
#include "i2c.h"
#include <stdio.h>


#define USARTz_RxPin             GPIO_Pin_3
#define USARTz_TxPin             GPIO_Pin_2


typedef struct 
{
	u8 receive;
	u8 TimeDisplay;
	u16 yimiao;
	u8 beidi;
	u8 tongdao;
		
}FLAG;

FLAG flag = {0,1,0,0,1};
u32 TimingDelay = 0;
u16 LEDRead = 0xffff;
u8 Key_value;
u8 beilv1,beilv2;
u8 str[20];
__IO uint8_t RxCounter2 = 0x00;
uint8_t RxBuffer2[20];
__IO uint16_t IC2ReadValue1 = 0, IC2ReadValue2 = 0;
__IO uint16_t CaptureNumber = 0;
__IO uint32_t Capture = 0;
__IO uint32_t TIM2Freq = 0;
__IO uint16_t IC3ReadValue1 = 0, IC3ReadValue2 = 0;
__IO uint16_t CaptureNumber2 = 0;
__IO uint32_t Capture2 = 0;
__IO uint32_t TIM2Freq2 = 0;
uint16_t capture3 = 0;


void Delay_Ms(u32 nTime);
void Lcd_init(void);
void Gpio_init(void);
void LED_off(void);
void LED_turn(uint16_t Led);
u8 Key_scan(void);
void Key_Check(void);
void show(void);
uint8_t I2C_Read(uint8_t add);
void I2C_Write(uint8_t add, uint8_t data);
void Usart2_init(void);
void NVIC_Configuration(void);
void rtc_init(void);
uint32_t Time_Regulate(void);
void Time_Adjust(void);
void Time_Show(void);
void Time_Display(uint32_t TimeVar);
void adc_init(void);
void ADC_Get(void);
void pwmfu_init(void);
void TIMB_init(void);
void TIMS_init(void);
//void TIMB2_init(void);

//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);

	Lcd_init();
	Gpio_init();
	i2c_init();
	Usart2_init();
	rtc_init();
	adc_init();
	pwmfu_init();		//当做波特发生器使用	 //实际上PWM波的捕获用的是PA2 但是USART用的RX也是PA2 ，不可能实现的。除非反复的初始化这俩，分时复用同一个IO口。
	TIMB_init();
	TIMS_init();
//	TIMB2_init();		//测试最后输出用，分析仪

	if(I2C_Read(0x30) != 30)
	{
		I2C_Write(0x01,2);
		I2C_Write(0x02,2);

		I2C_Write(0x30,30);
	}

	beilv1 = I2C_Read(0x01);
	beilv2 = I2C_Read(0x02);
	beilv1 = 2;
	beilv2 = 2;	

//	sprintf((char *)str,"%d %d ",beilv1,beilv2);
//
//	LCD_DisplayStringLine(Line0,str);

	while(1)
	{	
		Key_Check();
		show();
		Time_Show();
		ADC_Get();
			
	}
}


//TIM4_CH1 PB6
//TIM4_CH2 PB7

//void TIMB2_init(void)
//{
//	GPIO_InitTypeDef GPIO_InitStructure;
//	TIM_ICInitTypeDef  TIM_ICInitStructure;
//	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
//
//	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
//
//	
//  	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
//  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
//  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//   	GPIO_Init(GPIOB, &GPIO_InitStructure);
//
//
//	TIM_TimeBaseStructure.TIM_Period = 65535;
//  	TIM_TimeBaseStructure.TIM_Prescaler = 71;
//  	TIM_TimeBaseStructure.TIM_ClockDivision = 0;
//  	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
//	TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
//
//
//	TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
//  	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(TIM4, &TIM_ICInitStructure);
//  
//
//  /* TIM enable counter */
//  	TIM_Cmd(TIM4, ENABLE);
//
//  /* Enable the CC2 Interrupt Request */
//  	TIM_ITConfig(TIM4, TIM_IT_CC1, ENABLE);
//}

//TIM3_CH1  PA6
//TIM3_CH2  PA7
void TIMS_init(void)
{
	
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);	
	
	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);


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

	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
  	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  	TIM_OCInitStructure.TIM_Pulse = 65535;
  	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
  	TIM_OC1Init(TIM3, &TIM_OCInitStructure);
  	TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable);


	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  	TIM_OCInitStructure.TIM_Pulse = 65535;	
	TIM_OC2Init(TIM3, &TIM_OCInitStructure);
  	TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Disable);

	TIM_Cmd(TIM3, ENABLE);

  	TIM_ITConfig(TIM3, TIM_IT_CC1 | TIM_IT_CC2 , ENABLE);
		
}

//PA1 TIM2_CH2   
//PA2 TIM2_ch3
void TIMB_init(void)
{	
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_ICInitTypeDef  TIM_ICInitStructure;
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

	
  	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_1;
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   	GPIO_Init(GPIOA, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_2;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	


	TIM_TimeBaseStructure.TIM_Period = 65535;
  	TIM_TimeBaseStructure.TIM_Prescaler = 71;
  	TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);


	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);
  
  /* TIM enable counter */
  	TIM_Cmd(TIM2, ENABLE);

  /* Enable the CC2 Interrupt Request */
  	TIM_ITConfig(TIM2, TIM_IT_CC2, ENABLE);
	TIM_ITConfig(TIM2, TIM_IT_CC3, ENABLE);
	
			
}

void pwmfu_init(void)
{	 
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
	
  
  /* GPIOF Configuration: TIM10 Channel1 as alternate function push-pull */
  	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  	GPIO_Init(GPIOA, &GPIO_InitStructure);


	TIM_TimeBaseStructure.TIM_Period = 999;
  	TIM_TimeBaseStructure.TIM_Prescaler = 71;
  	TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);



	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  	TIM_OCInitStructure.TIM_Pulse = 500;
  	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

  	TIM_OC2Init(TIM1, &TIM_OCInitStructure);

  	TIM_OC2PreloadConfig(TIM1, TIM_OCPreload_Enable);
	
	TIM_CtrlPWMOutputs(TIM1, ENABLE);

  /* TIM10 enable counter */
  	TIM_Cmd(TIM1, ENABLE);
	
}

void ADC_Get(void)
{
	float   adc_value;
	ADC_SoftwareStartConvCmd(ADC1, ENABLE);	

	adc_value =  ADC_GetConversionValue(ADC1);

	adc_value = adc_value * 3.3 / 0xfff;

	sprintf((char *)str,"ADC : %.2f ",adc_value);
	LCD_DisplayStringLine(Line1,str);

}

void adc_init(void)
{	
	GPIO_InitTypeDef GPIO_InitStructure;
	ADC_InitTypeDef  ADC_InitStructure;

	RCC_ADCCLKConfig(RCC_PCLK2_Div6);

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
	
  /* Configure PC.04 (ADC Channel14) as analog input -------------------------*/
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
	GPIO_Init(GPIOB, &GPIO_InitStructure);

	
	ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
	ADC_InitStructure.ADC_ScanConvMode = DISABLE;
	ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
	ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
	ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  	ADC_InitStructure.ADC_NbrOfChannel = 1;
  	ADC_Init(ADC1, &ADC_InitStructure);

  /* ADC1 regular channel14 configuration */ 
  	ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_13Cycles5);


  /* Enable ADC1 */
  	ADC_Cmd(ADC1, ENABLE);

  /* Enable ADC1 reset calibration register */   
  	ADC_ResetCalibration(ADC1);
  /* Check the end of ADC1 reset calibration register */
  	while(ADC_GetResetCalibrationStatus(ADC1));

  /* Start ADC1 calibration */
  	ADC_StartCalibration(ADC1);
  /* Check the end of ADC1 calibration */
  	while(ADC_GetCalibrationStatus(ADC1));
		
}

void rtc_init(void)
{
	
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

  PWR_BackupAccessCmd(ENABLE);

  BKP_DeInit();

   RCC_LSICmd(ENABLE);

  while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET);


  RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);

  RCC_RTCCLKCmd(ENABLE);

  RTC_WaitForSynchro();

  RTC_WaitForLastTask();

  RTC_ITConfig(RTC_IT_SEC, ENABLE);

  RTC_WaitForLastTask();

  RTC_SetPrescaler(39999); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */

  RTC_WaitForLastTask();

  Time_Adjust();
  	
}

uint32_t Time_Regulate(void)
{
  uint32_t Tmp_HH = 23, Tmp_MM = 59, Tmp_SS = 55;

  return((Tmp_HH*3600 + Tmp_MM*60 + Tmp_SS));

}

void Time_Adjust(void)
{
  RTC_WaitForLastTask();

  RTC_SetCounter(Time_Regulate());

  RTC_WaitForLastTask();
}

void Time_Display(uint32_t TimeVar)
{
  uint32_t THH = 0, TMM = 0, TSS = 0;
  
  /* Reset RTC Counter when Time is 23:59:59 */
  if (RTC_GetCounter() == 0x00015180)
  {
     RTC_SetCounter(0x0);
     RTC_WaitForLastTask();
	 TimeVar = 	RTC_GetCounter();
  }
 
  /* Compute  hours */
  THH = TimeVar / 3600;
  /* Compute minutes */
  TMM = (TimeVar % 3600) / 60;
  /* Compute seconds */
  TSS = (TimeVar % 3600) % 60;

  sprintf((char *)str,"Time: %0.2d:%0.2d:%0.2d", THH, TMM, TSS);
  LCD_DisplayStringLine(Line0,str);

}

void Time_Show(void)
{
    /* If 1s has been elapsed */
    if (flag.TimeDisplay == 1)
    {
      Time_Display(RTC_GetCounter());
      flag.TimeDisplay = 0;
    }
}

void Gpio_init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC |RCC_APB2Periph_GPIOD |
                         RCC_APB2Periph_AFIO, ENABLE);

/*************************************LED_init*************************/
	GPIO_InitStructure.GPIO_Pin = LEDALL;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
	LED_off();

}

void show(void)	
{
	if(flag.receive == 1)
	{
		flag.receive = 0;
		printf((char *)RxBuffer2);
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	}
	sprintf((char *)str," Channel(1): %dHz ", TIM2Freq);

	if(flag.tongdao == 1)
	{
		LCD_SetTextColor(Red);	
	}
  	LCD_DisplayStringLine(Line2,str);	

	sprintf((char *)str," N(1): %d            ", beilv1);
  	LCD_DisplayStringLine(Line3,str);
	
	if(flag.tongdao == 1)
	{
		LCD_SetTextColor(White);	
	}


	if(flag.tongdao == 2)
	{
		LCD_SetTextColor(Red);	
	}
	sprintf((char *)str," Channel(2): %dHz ", TIM2Freq2);


  	LCD_DisplayStringLine(Line4,str);	
	
	sprintf((char *)str," N(2): %d            ", beilv2);
  	LCD_DisplayStringLine(Line5,str);
							
	if(flag.tongdao == 2)
	{
		LCD_SetTextColor(White);	
	}

	LCD_DisplayStringLine(Line6,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line7,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line8,(unsigned char *)"                    ");	
	if(flag.beidi == 0)	
	LCD_DisplayStringLine(Line9,(unsigned char *)"                   1");
	else if(flag.beidi != 0)
	LCD_DisplayStringLine(Line9,(unsigned char *)"                   2");		
}

void Key_Check(void)
{
	Key_value = Key_scan();
	
	if(Key_value == 1)
	{
		flag.beidi = ~flag.beidi;
	}		  

	if(flag.beidi != 0)
	{
		if(Key_value == 2)
		{
			flag.tongdao ++;
			if(flag.tongdao == 3)
			flag.tongdao = 1;
		}
	
		if(Key_value == 3)
		{
			if(flag.tongdao == 1)
			{
				beilv1++;
				if(beilv1 == 11)
				beilv1 = 10;
			}	

			if(flag.tongdao == 2)
			{
				beilv2++;
				if(beilv2 == 11)
				beilv2 = 10;
			}
		}
	
		if(Key_value == 4)
		{
			if(flag.tongdao == 1)
			{
				beilv1--;
				if(beilv1 == 0)
				beilv1 = 1;
			}	

			if(flag.tongdao == 2)
			{
				beilv2--;
				if(beilv2 == 0)
				beilv2 = 1;
			}
		}	
	}
}

u8 Key_scan(void)		 
{
	if(RB1 == 0)
	{
		Delay_Ms(5);
		if(RB1 == 0)
		{
		
		}
		while(!RB1);
		return 1;
	}
	
	if(RB2 == 0)
	{
		Delay_Ms(5);
		if(RB2 == 0)
		{
		
		}
		while(!RB2);
		return 2;
	}
	
	if(RB3 == 0)
	{
		Delay_Ms(5);
		if(RB3 == 0)
		{
			 
		}
		while(!RB3);
		return 3;
	}
	
	if(RB4 == 0)
	{
		Delay_Ms(5);
		if(RB4 == 0)
		{
			 
		}
		while(!RB4);
		return 4;
	}
	return 0;	
}

void Usart2_init(void)
{
	  GPIO_InitTypeDef GPIO_InitStructure;
	  USART_InitTypeDef USART_InitStructure;

	  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 , ENABLE);

	  NVIC_Configuration();

	  GPIO_InitStructure.GPIO_Pin = USARTz_RxPin;
	  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	  GPIO_Init(GPIOA, &GPIO_InitStructure);  
	  
	  GPIO_InitStructure.GPIO_Pin = USARTz_TxPin; 
	  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	  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 | USART_Mode_Tx;
	  USART_Init(USART2, &USART_InitStructure);
	  

	
	  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	

	  USART_Cmd(USART2, ENABLE);
			
}


void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  

  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);


  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 4;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

}



int fputc(int ch, FILE *f)
{
	USART_SendData(USART2, (uint8_t) ch);

  	while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);

  	return ch;
}

void LED_turn(uint16_t Led)
{	
 	GPIOC->ODR = LEDRead;
	LEDRead ^= Led;
	GPIOC->ODR = LEDRead;	
	GPIO_SetBits(GPIOD, GPIO_Pin_2);
	GPIO_ResetBits(GPIOD, GPIO_Pin_2);
	LEDRead = GPIOC->ODR;
}

void LED_off(void)
{
	GPIOC->ODR = LEDRead;
	GPIO_SetBits(GPIOC, LEDALL);	
	GPIO_SetBits(GPIOD, GPIO_Pin_2);
	GPIO_ResetBits(GPIOD, GPIO_Pin_2);
	LEDRead = GPIOC->ODR;	
}

void Lcd_init(void)
{
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(Blue);
	LCD_SetTextColor(White);
	
	LCD_DisplayStringLine(Line0,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line1,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line2,(unsigned char *)"                    ");
	LCD_DisplayStringLine(Line3,(unsigned char *)"                    ");
	LCD_DisplayStringLine(Line4,(unsigned char *)"                    ");						
	LCD_DisplayStringLine(Line5,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line6,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line7,(unsigned char *)"                    ");	
	LCD_DisplayStringLine(Line8,(unsigned char *)"                    ");		
	LCD_DisplayStringLine(Line9,(unsigned char *)"                    ");	

}
//
uint8_t I2C_Read(uint8_t add)
{
	 uint8_t temp;
	 I2CStart();
	 I2CSendByte(0xa0);
	 I2CSendAck();

	 I2CSendByte(add);
	 I2CSendAck();

	 I2CStart();

	 I2CSendByte(0xa1);
	 I2CSendAck();

	 
	 temp =  I2CReceiveByte();

	 I2CStop();

	 Delay_Ms(10);
	 
	 return temp;	
}

void I2C_Write(uint8_t add, uint8_t data)
{
	 I2CStart();
	 I2CSendByte(0xa0);
	 I2CSendAck();

	 I2CSendByte(add);
	 I2CSendAck();

	 I2CSendByte(data);
	 I2CSendAck();

	 I2CStop();

	 Delay_Ms(10);
}


void Delay_Ms(u32 nTime)
{

	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

void RTC_IRQHandler(void)
{
  if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
  {

    RTC_ClearITPendingBit(RTC_IT_SEC);

    flag.TimeDisplay = 1;

    RTC_WaitForLastTask();
    
  }
}

void SysTick_Handler(void)
{
	TimingDelay--;
	flag.yimiao++;
	if(flag.yimiao == 999)
	{
		LED_turn(LED1);
		flag.yimiao = 0;
	}
	if(flag.yimiao == 400)
		LED_turn(LED2);
	if(flag.yimiao == 600)
		LED_turn(LED3);		  //灯是随便写的，不想写了，比较简单的实现，但是由于之前的根本没法实现，所以就随便亮了亮
}


void USART2_IRQHandler(void)
{
	uint8_t temp;
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
	{
	    
		temp = USART_ReceiveData(USART2);
		RxBuffer2[RxCounter2++] = temp;	   	
	}
	if(temp == '\n')
	{
		 RxBuffer2[RxCounter2 + 1] = 0;

		 USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);

		 flag.receive = 1;
		 RxCounter2 = 0;
	}
  
}

void TIM2_IRQHandler(void)
{ 

 if(TIM_GetITStatus(TIM2, TIM_IT_CC3) == SET) 
  {
    TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
    if(CaptureNumber2 == 0)
    {
      IC3ReadValue1 = TIM_GetCapture3(TIM2);
      CaptureNumber2 = 1;
    }
    else if(CaptureNumber2 == 1)
    {
      /* Get the Input Capture value */
      IC3ReadValue2 = TIM_GetCapture3(TIM2); 
      
      /* Capture computation */
      if (IC3ReadValue2 > IC3ReadValue1)
      {
        Capture2 = (IC3ReadValue2 - IC2ReadValue1); 
      }
      else
      {
        Capture2 = ((0xFFFF - IC3ReadValue1) + IC3ReadValue2); 
      }
      /* Frequency computation */ 
      TIM2Freq2 = (uint32_t) SystemCoreClock / Capture2 / 72;
      CaptureNumber2 = 0;
    }
  }


  if(TIM_GetITStatus(TIM2, TIM_IT_CC2) == SET) 
  {
    TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
    if(CaptureNumber == 0)
    {
      IC2ReadValue1 = TIM_GetCapture2(TIM2);
      CaptureNumber = 1;
    }
    else if(CaptureNumber == 1)
    {
      /* Get the Input Capture value */
      IC2ReadValue2 = TIM_GetCapture2(TIM2); 
      
      /* Capture computation */
      if (IC2ReadValue2 > IC2ReadValue1)
      {
        Capture = (IC2ReadValue2 - IC2ReadValue1); 
      }
      else
      {
        Capture = ((0xFFFF - IC2ReadValue1) + IC2ReadValue2); 
      }
      /* Frequency computation */ 
      TIM2Freq = (uint32_t) SystemCoreClock / Capture / 72;
      CaptureNumber = 0;
    }
  }

 
}


void TIM3_IRQHandler(void)
{
  uint16_t  value;
  if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
  {
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
    capture3 = TIM_GetCapture1(TIM3);
	value =  capture3 + (500000 / TIM2Freq / beilv1);
    TIM_SetCompare1(TIM3, value );
  }												 

  if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
  {
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
    capture3 = TIM_GetCapture2(TIM3);
	value = capture3 + (500000 / TIM2Freq / beilv2);
    TIM_SetCompare2(TIM3, value );
  }

}

//void TIM4_IRQHandler(void)
//{ 
//
//   if(TIM_GetITStatus(TIM4, TIM_IT_CC1) == SET) 
//  {
//    TIM_ClearITPendingBit(TIM4, TIM_IT_CC1);
//    if(CaptureNumber2 == 0)
//    {
//      IC3ReadValue1 = TIM_GetCapture1(TIM4);
//      CaptureNumber2 = 1;
//    }
//    else if(CaptureNumber2 == 1)
//    {
//      /* Get the Input Capture value */
//      IC3ReadValue2 = TIM_GetCapture1(TIM4); 
//      
//      /* Capture computation */
//      if (IC3ReadValue2 > IC3ReadValue1)
//      {
//        Capture2 = (IC3ReadValue2 - IC2ReadValue1); 
//      }
//      else
//      {
//        Capture2 = ((0xFFFF - IC3ReadValue1) + IC3ReadValue2); 
//      }
//      /* Frequency computation */ 
//      TIM2Freq2 = (uint32_t) SystemCoreClock / Capture2 / 72;
//      CaptureNumber2 = 0;
//    }
//  }
//
// 
//}

#ifndef __LED_H
#define __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_All    

#define RB1 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
#define RB2 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8)
#define RB3 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)
#define RB4 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2)       

#endif