自学教程：C++ CLK_PeripheralClockConfig函数代码示例

/**  * @brief  Initializes peripherals used by the I2C EEPROM driver.  * @param  None  * @retval None  */void sEE_LowLevel_Init(void){  /*!< sEE_I2C Periph clock enable */  CLK_PeripheralClockConfig(sEE_I2C_CLK, ENABLE);  /*!< Enable the DMA clock */  CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);  /* I2C TX DMA Channel configuration */  DMA_DeInit(sEE_I2C_DMA_CHANNEL_TX);  DMA_Init(sEE_I2C_DMA_CHANNEL_TX,           0, /* This parameter will be configured durig communication */           sEE_I2C_DR_Address,           0xFF, /* This parameter will be configured durig communication */           DMA_DIR_PeripheralToMemory,/* This parameter will be configured durig communication */           DMA_Mode_Normal,           DMA_MemoryIncMode_Inc,           DMA_Priority_VeryHigh,           DMA_MemoryDataSize_Byte);  /* I2C RX DMA Channel configuration */  DMA_DeInit(sEE_I2C_DMA_CHANNEL_RX);  DMA_Init(sEE_I2C_DMA_CHANNEL_RX, 0, /* This parameter will be configured durig communication */           sEE_I2C_DR_Address,           0xFF, /* This parameter will be configured durig communication */           DMA_DIR_PeripheralToMemory,/* This parameter will be configured durig communication */           DMA_Mode_Normal,           DMA_MemoryIncMode_Inc,           DMA_Priority_VeryHigh,           DMA_MemoryDataSize_Byte);}

/**  * @brief This function initializes in Ultra Low Power mode, 	*				disable the LCD, LSE and configures the unused IOs 	*				in output push-pull	* @caller main and ADC_Icc_Test  * @param None  * @retval None  */ void Halt_Init(void){/* Set STM8 in low power */  PWR->CSR2 = 0x2;    LCD_Cmd(DISABLE);  /* To wait LCD disable */  while ((LCD->CR3 & 0x40) != 0x00);  /* Set GPIO in low power*/	  GPIO_LowPower_Config();  /* Stop RTC Source clock */  CLK_RTCClockConfig(CLK_RTCCLKSource_Off, CLK_RTCCLKDiv_1);    #ifdef USE_LSE    CLK_LSEConfig(CLK_LSE_OFF);    while ((CLK->ECKCR & 0x04) != 0x00);  #else    CLK_LSICmd(DISABLE);    while ((CLK->ICKCR & 0x04) != 0x00);  #endif    /* Stop clock RTC and LCD */ 	  CLK_PeripheralClockConfig(CLK_Peripheral_RTC, DISABLE);  CLK_PeripheralClockConfig(CLK_Peripheral_LCD, DISABLE);}

/*主程序*/void main(){		CLK_Config();	CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, ENABLE);		CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER3, ENABLE);		/* Check if the system has resumed from IWDG reset */	if (RST_GetFlagStatus(RST_FLAG_IWDGF) != RESET)	{	  /* Clear IWDGF Flag */	  RST_ClearFlag(RST_FLAG_IWDGF);	}		/*通信串口初始化*/	DBG_Config();		IR_Init();		printf("starting.../n");	/*打开全局中断*/	enableInterrupts();    	while (1)	{		IR_Process();	}		}

char sampleADC(void){    char res = 0x0;    CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);    ADC_DeInit(ADC1);    ADC_VrefintCmd(ENABLE);    delay_10us(3);    ADC_Cmd(ADC1, ENABLE);    ADC_Init(ADC1, ADC_ConversionMode_Single,             ADC_Resolution_6Bit, ADC_Prescaler_1);    ADC_SamplingTimeConfig(ADC1, ADC_Group_SlowChannels, ADC_SamplingTime_9Cycles);    ADC_ChannelCmd(ADC1, ADC_Channel_0, ENABLE);    delay_10us(3);    ADC_SoftwareStartConv(ADC1);    while( ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == 0);    res = (char)ADC_GetConversionValue(ADC1);    ADC_VrefintCmd(DISABLE);    ADC_DeInit(ADC1);    /* disable SchmittTrigger for ADC_Channel_24, to save power */    //ADC_SchmittTriggerConfig(ADC1, ADC_Channel_24, DISABLE);    CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, DISABLE);    ADC_ChannelCmd(ADC1, ADC_Channel_0, DISABLE);    return res;}

void ADC_Config(void){	CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);	CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);		ADC_Init(ADC1, ADC_ConversionMode_Continuous, ADC_Resolution_12Bit, ADC_Prescaler_2);	ADC_SamplingTimeConfig(ADC1, ADC_Group_SlowChannels, ADC_SamplingTime_384Cycles);	ADC_Cmd(ADC1, ENABLE);		ADC_ChannelCmd(ADC1, ADC_Channel_24, ENABLE); //设置ADC通道		SYSCFG_REMAPDMAChannelConfig(REMAP_DMA1Channel_ADC1ToChannel0);		DMA_Init(DMA1_Channel0, 		BUFFER_ADDRESS,		ADC1_DR_ADDRESS,		BUFFER_SIZE,		DMA_DIR_PeripheralToMemory,		DMA_Mode_Circular,		DMA_MemoryIncMode_Inc,		DMA_Priority_High,		DMA_MemoryDataSize_HalfWord);		DMA_Cmd(DMA1_Channel0, ENABLE);	DMA_ITConfig(DMA1_Channel0, DMA_ITx_TC, ENABLE);	DMA_GlobalCmd(ENABLE);}        

/**  * @brief  delay for some time in ms unit  * @param  n_ms is how many ms of time to delay  * @retval None  */void delay_ms(u16 n_ms){/* Init TIMER 4 */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, ENABLE);/* Init TIMER 4 prescaler: TIM4_Prescaler_1: 38KHz / 1 = 38KHz */  TIM4->PSCR = 0;/* LSI 38KHz --> Auto-Reload value: 38KHz / 1 = 38KHz, 38KHz / 1k = 38 */  TIM4->ARR = 38;  /* Counter value: 4, to compensate the initialization of TIMER*/      TIM4->CNTR = 4;  //value may have to be changed/* clear update flag */  TIM4->SR1 &= (u8)(~TIM4_FLAG_Update);/* Enable Counter */  TIM4->CR1 |= TIM4_CR1_CEN;  while(n_ms--)  {    while((TIM4->SR1 & TIM4_FLAG_Update) == 0);    TIM4->SR1 &= (u8)(~TIM4_FLAG_Update);  }/* Disable Counter */  TIM4->CR1 &= (u8)(~TIM4_CR1_CEN);  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, DISABLE);}

/**  * @brief  delay for some time in ms unit  * @caller auto_test  * @param  n_ms is how many ms of time to delay  * @retval None  */static void delay_ms(u16 n_ms){	/* Init TIMER 4 */	CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, ENABLE);	/* Init TIMER 4 prescaler: / (2^6) = /64 */	TIM2->PSCR = 6;	/* HSI div by 1 --> Auto-Reload value: 16M / 64 = 1/4M, 1/4M / 1k = 250*/	TIM2->ARRH = 0;	TIM2->ARRL = 250;	/* Counter value: 2, to compensate the initialization of TIMER*/	TIM2->CNTRH = 0;	TIM2->CNTRL = 2;	/* clear update flag */	TIM2->SR1 &= ~TIM_SR1_UIF;	/* Enable Counter */	TIM2->CR1 |= TIM_CR1_CEN;	while(n_ms--)	{	while((TIM2->SR1 & TIM_SR1_UIF) == 0) ;	TIM2->SR1 &= ~TIM_SR1_UIF;	}	/* Disable Counter */	TIM2->CR1 &= ~TIM_CR1_CEN;	CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, DISABLE);}

/**  * @brief  delay for some time in 10us unit(partial accurate)  * @caller auto_test  * @param n_10us is how many 10us of time to delay  * @retval None  */static void delay_10us(u16 n_10us){	/* Init TIMER 4 */	CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, ENABLE);	/* prescaler: / (2^0) = /1 */	TIM2->PSCR = 0;	/* SYS_CLK_HSI_DIV1 Auto-Reload value: 16M / 1 = 16M, 16M / 100k = 160 */	TIM2->ARRH = 0;	TIM2->ARRL = 160;	/* Counter value: 10, to compensate the initialization of TIMER */	TIM2->CNTRH = 0;	TIM2->CNTRL = 10;	/* clear update flag */	TIM2->SR1 &= ~TIM_SR1_UIF;	/* Enable Counter */	TIM2->CR1 |= TIM_CR1_CEN;	while(n_10us--)	{		while((TIM2->SR1 & TIM_SR1_UIF) == 0) ;		TIM2->SR1 &= ~TIM_SR1_UIF;	}	/* Disable Counter */	TIM2->CR1 &= ~TIM_CR1_CEN;	CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, DISABLE);}

/**  * @brief  Delay x sec  * @param  Seconds : number of seconds to delay  * @retval None.  * Note : TIM4 is configured for a system clock = 2MHz  */void Delay_Seconds(uint8_t Seconds){  uint8_t i = 0;  /* Enable TIM4 Clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, ENABLE);  /* Configure TIM4 to generate an update event each 1 s */  TIM4_TimeBaseInit(TIM4_Prescaler_16384, 123);  /* Enable TIM4 */  TIM4_Cmd(ENABLE);  /* Clear the Flag */  TIM4_ClearFlag(TIM4_FLAG_Update);  for (i = 0; i < Seconds; i++)  {    /* Wait 1 sec */    while ( TIM4_GetFlagStatus(TIM4_FLAG_Update) == RESET )    {}    /* Clear the Flag */    TIM4_ClearFlag(TIM4_FLAG_Update);  }  /* Disable TIM4 */  TIM4_Cmd(DISABLE);  /* Disable TIM4 Clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, DISABLE);}

/**  * @brief  Configure peripherals clock   * @param  None  * @retval None  */static void CLK_Config(void){  /* Enable ADC1 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);    /* Enable COMP clock */  CLK_PeripheralClockConfig(CLK_Peripheral_COMP, ENABLE);}

/**  * @brief  Configure peripherals Clock     * @param  None  * @retval None  */static void CLK_Config(void){  /* Enable TIM1 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM1, ENABLE);  /* Enable TIM2 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, ENABLE);  /* Enable TIM3 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM3, ENABLE);}

/**  * @brief  Read ADC1	* @caller several functions  * @param None  * @retval ADC value  */ u16 ADC_Supply(void){	uint8_t i;	uint16_t res;/* Enable ADC clock */  CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);/* de-initialize ADC */  ADC_DeInit(ADC1);/*ADC configuration  ADC configured as follow:  - Channel VREF  - Mode = Single ConversionMode(ContinuousConvMode disabled)  - Resolution = 12Bit  - Prescaler = /1  - sampling time 9 */    ADC_VrefintCmd(ENABLE);  delay_10us(3);      ADC_Cmd(ADC1, ENABLE);	   ADC_Init(ADC1, ADC_ConversionMode_Single,  ADC_Resolution_12Bit, ADC_Prescaler_1);    ADC_SamplingTimeConfig(ADC1, ADC_Group_FastChannels, ADC_SamplingTime_9Cycles);  ADC_ChannelCmd(ADC1, ADC_Channel_Vrefint, ENABLE);  delay_10us(3);/* initialize result */  res = 0;  for(i=8; i>0; i--)  {/* start ADC convertion by software */    ADC_SoftwareStartConv(ADC1);/* wait until end-of-covertion */    while( ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == 0 );/* read ADC convertion result */    res += ADC_GetConversionValue(ADC1);  }	/* de-initialize ADC */  ADC_VrefintCmd(DISABLE);  ADC_DeInit(ADC1);  /* disable SchmittTrigger for ADC_Channel_24, to save power */  ADC_SchmittTriggerConfig(ADC1, ADC_Channel_24, DISABLE);	  CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, DISABLE);  ADC_ChannelCmd(ADC1, ADC_Channel_Vrefint, DISABLE);	  return (res>>3);}

void Battery_Int_Measure(float * p_bat_voltage){	float voltage_shift = 0;	float voltage_VCC = 0;		#ifdef BATTERY_DEBUG		printf("[Battery] Start measuring battery .../r/n");	#endif	result = 0;	GPIO_Init(GPIO_PORT_ADC_OUT, GPIO_PIN_ADC_OUT, GPIO_Mode_Out_PP_High_Fast);	GPIO_Init(GPIO_PORT_VTEST_5V, GPIO_PIN_VTEST_5V, GPIO_Mode_In_FL_No_IT);	/* Enable ADC1 clock */    CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);    ADC_Config();    /* Infinite loop*/    for(uint8_t i = 0;i < BUFFER_SIZE;i ++)    {        /* Start ADC1 Conversion using Software trigger*/        ADC_SoftwareStartConv(ADC1);        /* Wait until ADC Channel 15 end of conversion */        while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET)        {}                /* read ADC convertion result */        adc_value[i] = ADC_GetConversionValue(ADC1);		result += adc_value[i];    }	voltage_shift = (result * 3.6) / (BUFFER_SIZE * 4096);	voltage_VCC = (voltage_shift * (BAT_INT_SHIFT_PULLDOWN_RES + BAT_INT_SHIFT_PULLUP_RES)) / BAT_INT_SHIFT_PULLDOWN_RES;	/* Disable ADC1 */    ADC_Cmd(ADC1, DISABLE);	/* Disable ADC1 clock */    CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, DISABLE);		GPIO_Init(GPIO_PORT_ADC_OUT, GPIO_PIN_ADC_OUT, GPIO_Mode_Out_PP_Low_Fast);	GPIO_Init(GPIO_PORT_VTEST_5V, GPIO_PIN_VTEST_5V, GPIO_Mode_Out_PP_Low_Fast);	*p_bat_voltage = voltage_VCC;		#ifdef BATTERY_DEBUG		for (uint8_t i = 0; i < BUFFER_SIZE; i++)        {            printf("[Battery] voltage is 0x%04x/r/n",adc_value[i]);		}	#endif}

/**  * @brief  Configure peripherals clock   * @param  None  * @retval None  */static void CLK_Config(void){  /* Enable ADC1 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);  /* Enable TIM1 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM1, ENABLE);  /* Enable DMA1 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);}

/*名称: void I2C_RTC_Init(void)功能: 硬件IIC初始化形参: 无返回值：无*/ void IIC_RTC_Init(void){  I2C_Cmd(DISABLE);  I2C_DeInit();  CLK_PeripheralClockConfig(CLK_PERIPHERAL_I2C, DISABLE);  GPIO_Init(GPIOE, GPIO_PIN_1, GPIO_MODE_IN_PU_NO_IT);  GPIO_Init(GPIOE, GPIO_PIN_2, GPIO_MODE_IN_PU_NO_IT);  CLK_PeripheralClockConfig(CLK_PERIPHERAL_I2C, ENABLE);  I2C_Cmd( ENABLE);  I2C_Init(400000, 0xA0, I2C_DUTYCYCLE_2, I2C_ACK_CURR,            I2C_ADDMODE_7BIT, 16);}

void LCD_HardwareInit(void){  unsigned long segments = S8 | S9 | S10 | S11 | S12 | S13 | S14 | S15 | S16 | S17 | S18 | S19;  CLK_RTCClockConfig(CLK_RTCCLKSource_LSI, CLK_RTCCLKDiv_2);  CLK_PeripheralClockConfig(CLK_Peripheral_RTC, ENABLE);    CLK_PeripheralClockConfig(CLK_Peripheral_LCD, ENABLE);  LCD_Init(LCD_Prescaler_4, LCD_Divider_24, LCD_Duty_1_3, LCD_Bias_1_3, LCD_VoltageSource_External);  LCD_PortMaskConfig(LCD_PortMaskRegister_1, (uint8_t)(segments >> 8));  LCD_PortMaskConfig(LCD_PortMaskRegister_2, (uint8_t)(segments >> 16));  LCD_PortMaskConfig(LCD_PortMaskRegister_3, (uint8_t)(segments >> 24));  LCD_PulseOnDurationConfig(LCD_PulseOnDuration_0);  LCD_ContrastConfig(LCD_Contrast_Level_7);  LCD_Cmd(ENABLE);}

/**  * @brief this function checks if a NDEF message is available in the M24LR04E-R EEPROM	* @par PayloadLength : the number of byte of the NDEF message  * @retval SUCCESS : A NDEF message has been found	* @retval ERROR :  a NDEF message doens't have been found  */static int8_t User_WriteFirmwareVersion ( void )			{uint8_t *OneByte = 0x00;uint16_t WriteAddr = 0x01FC;								M24LR04E_Init();			M24LR04E_WriteOneByte (M24LR16_EEPROM_ADDRESS_USER, WriteAddr++, FirmwareVersion [0]);					I2C_Cmd(M24LR04E_I2C, DISABLE);						CLK_PeripheralClockConfig(CLK_Peripheral_I2C1, DISABLE);			GPIO_HIGH(M24LR04E_I2C_SCL_GPIO_PORT,M24LR04E_I2C_SCL_PIN);		GPIO_HIGH(M24LR04E_I2C_SCL_GPIO_PORT,M24LR04E_I2C_SDA_PIN);						M24LR04E_DeInit();	I2C_Cmd(M24LR04E_I2C, DISABLE);			return SUCCESS;}

static void TIM2_Config(void){  /* Enable TIM2 CLK */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, ENABLE);    /* Capture only every 8 events!!! */  /* Enable capture of TIM2 */  TIM2_ICInit(TIM2_Channel_1, TIM2_ICPolarity_Falling, TIM2_ICSelection_DirectTI, TIM2_ICPSC_Div8, 0);    /* Enable timer1 */  TIM2_Cmd(ENABLE);    /* Config Channel 1 pin*/  GPIO_Init(GPIOB, GPIO_Pin_0, GPIO_Mode_In_PU_No_IT);  /* Clear CC1 Flag*/  TIM2_ClearFlag(TIM2_FLAG_CC1);    /* wait a Capture on CC1 */  while((TIM2->SR1 & TIM2_FLAG_CC1) != TIM2_FLAG_CC1);    /* Get CCR1 value*/  ICValue1 = TIM2_GetCapture1();  /* Clear CC1 Flag*/  TIM2_ClearFlag(TIM2_FLAG_CC1);    /* wait a capture on cc1 */  while((TIM2->SR1 & TIM2_FLAG_CC1) != TIM2_FLAG_CC1);  /* Get CCR1 value*/  ICValue2 = TIM2_GetCapture1();  TIM2_ClearFlag(TIM2_FLAG_CC1); }

/**  * @brief ADC_Icc(ADC_24 of ADC_0~27) initialization	* @caller main and ADC_Icc_Test  * @param None  * @retval None  */ void ADC_Icc_Init(void){/* Enable ADC clock */  CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);/* de-initialize ADC */  ADC_DeInit(ADC1);	/*  ADC configured as follow:  - NbrOfChannel = 1 - ADC_Channel_24  - Mode = Single ConversionMode(ContinuousConvMode disabled)  - Resolution = 12Bit  - Prescaler = /1  - sampling time 159 */	/* Enable ADC1 */  ADC_Cmd(ADC1, ENABLE);  ADC_Init(ADC1, ADC_ConversionMode_Single,ADC_Resolution_12Bit, ADC_Prescaler_1);  ADC_SamplingTimeConfig(ADC1, ADC_Group_FastChannels, ADC_SamplingTime_9Cycles);  ADC_ChannelCmd(ADC1, ADC_Channel_24, ENABLE);/* disable SchmittTrigger for ADC_Channel_24, to save power */  ADC_SchmittTriggerConfig(ADC1, ADC_Channel_24, DISABLE);/* a short time of delay is required after enable ADC */  delay_10us(3);	}

/**  * @brief  Main program.  * @param  None  * @retval None  */void main(void){    /* I2C  clock Enable*/    CLK_PeripheralClockConfig(CLK_Peripheral_I2C, ENABLE);    /* system_clock / 1 */    CLK_MasterPrescalerConfig(CLK_MasterPrescaler_HSIDiv1);    /* Initialize LEDs mounted on the EVAL board */    STM_EVAL_LEDInit(LED2);    STM_EVAL_LEDInit(LED3);    I2C_DeInit();    /* Initialize I2C peripheral */#ifdef I2C_slave_7Bits_Address    I2C_Init(100000, SLAVE_ADDRESS, I2C_DutyCycle_2, I2C_Ack_Enable,             I2C_AcknowledgedAddress_7bit);#else    I2C_Init(100000, SLAVE_ADDRESS, I2C_DutyCycle_2, I2C_Ack_Enable,             I2C_AcknowledgedAddress_10bit);#endif    /* Enable Error Interrupt*/    I2C_ITConfig((I2C_IT_TypeDef)(I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);    /* Enable general interrupts */    enableInterrupts();    /*Main Loop */    while (1)    {        /* infinite loop */    }}

static void HalConsoleDMAConfigration(void){  CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);    /* Deinitialize DMA channels */  DMA_GlobalDeInit();    DMA_DeInit(USART_DMA_CHANNEL_TX);  DMA_DeInit(USART_DMA_CHANNEL_RX);    /* DMA channel Rx of USART Configuration */  DMA_Init(USART_DMA_CHANNEL_RX, (uint16_t)HalConsoleRxBuffer, (uint16_t)USART_DR_ADDRESS,           sizeof(HalConsoleRxBuffer), DMA_DIR_PeripheralToMemory, DMA_Mode_Normal,           DMA_MemoryIncMode_Inc, DMA_Priority_Low, DMA_MemoryDataSize_Byte);      /* Enable the USART Tx/Rx DMA requests */  USART_DMACmd(USART2, USART_DMAReq_TX, ENABLE);  USART_DMACmd(USART2, USART_DMAReq_RX, ENABLE);    /* Global DMA Enable */  DMA_GlobalCmd(ENABLE);    /* Enable the USART Rx DMA channel */  DMA_Cmd(USART_DMA_CHANNEL_RX, ENABLE);  USART_Cmd(USART2, ENABLE);}

/**  * @brief  Initializes the SD_SPI and CS pins.  * @param  None  * @retval None  */void SD_LowLevel_Init(void){  /* Enable SPI clock */  CLK_PeripheralClockConfig(SD_SPI_CLK, ENABLE);  /* Set the MOSI,MISO and SCK at high level */  GPIO_ExternalPullUpConfig(SD_SPI_SCK_GPIO_PORT, SD_SPI_MISO_PIN | SD_SPI_MOSI_PIN | /                            SD_SPI_SCK_PIN, ENABLE);  /* SPI2 pin remap on Port I*/  SYSCFG_REMAPPinConfig(REMAP_Pin_SPI2Full, ENABLE);  /* SD_SPI Config */  SPI_Init(SD_SPI, SPI_FirstBit_MSB, SPI_BaudRatePrescaler_4, SPI_Mode_Master,           SPI_CPOL_High, SPI_CPHA_2Edge, SPI_Direction_2Lines_FullDuplex,           SPI_NSS_Soft, 0x07);  /* SD_SPI enable */  SPI_Cmd(SD_SPI, ENABLE);  /* Configure the SD_Detect pin */  GPIO_Init(SD_DETECT_GPIO_PORT, SD_DETECT_PIN, GPIO_Mode_In_PU_No_IT);  /* Set MSD ChipSelect pin in Output push-pull high level */  GPIO_Init(SD_CS_GPIO_PORT, SD_CS_PIN, GPIO_Mode_Out_PP_High_Slow);}

/**  * @brief  init usart1   * @param  None  * @retval None  */void Init_usart1(uint32_t BaudRate){	CLK_PeripheralClockConfig(CLK_Peripheral_USART1, ENABLE);	USART_Init(USART1, BaudRate, USART_WordLength_8b, USART_StopBits_1, USART_Parity_No, USART_Mode_Tx|USART_Mode_Rx);	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);	USART_Cmd(USART1, ENABLE);}

/**  * @brief  Configure ADC and Analog watchdog  * @param  None  * @retval None  */static void ADC_Config(void){    /* Enable ADC1 clock */    CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);    /* Initialise and configure ADC1 */    ADC_Init(ADC1, ADC_ConversionMode_Continuous, ADC_Resolution_12Bit, ADC_Prescaler_2);    ADC_SamplingTimeConfig(ADC1, ADC_Group_SlowChannels, ADC_SamplingTime_384Cycles);    /* Enable ADC1 */    ADC_Cmd(ADC1, ENABLE);    /* Enable ADC1 Channel 3 */    ADC_ChannelCmd(ADC1, ADC_Channel_3, ENABLE);    /* Calculate Threshold data value*/    HighThresholdData = (uint16_t)(((uint32_t)HIGH_THRESHOLD_VOLTAGE * 1000) / (uint32_t)ADC_RATIO) ;    LowThresholdData  = (uint16_t)(((uint32_t)LOW_THRESHOLD_VOLTAGE * 1000) / (uint32_t)ADC_RATIO) ;    /* Configure Analog Watchdog selected channel and Thresholds */    ADC_AnalogWatchdogConfig(ADC1, ADC_AnalogWatchdogSelection_Channel3,                             HighThresholdData,                             LowThresholdData);    /* Enable Analog watchdog ADC1 Interrupt */    ADC_ITConfig(ADC1, ADC_IT_AWD, ENABLE);    /* Enable Interrupts */    enableInterrupts();    /* Start ADC1 Conversion using Software trigger*/    ADC_SoftwareStartConv(ADC1);}

/* ******************************************************************************* *                                 FUNCTIONS                                  ******************************************************************************* */void HalLightInit(void){  /* Enable TIM1 clock */  CLK_PeripheralClockConfig(CLK_Peripheral_TIM1, ENABLE);    /* GPIOD configuration */  GPIO_Init(GPIOD, GPIO_Pin_2, GPIO_Mode_Out_PP_Low_Fast);  GPIO_Init(GPIOD, GPIO_Pin_3, GPIO_Mode_Out_PP_Low_Fast);  GPIO_SetBits(GPIOD, GPIO_Pin_3); /* Close relay output */  /*  - TIM1CLK = 16 MHz  - TIM1 counter clock = TIM1CLK / 320 = 16MHz/320 = 50000Hz  */  /* Time base configuration */  TIM1_TimeBaseInit(320, TIM1_CounterMode_Up, 100, 0);    TIM1_OC1Init(TIM1_OCMode_PWM1, TIM1_OutputState_Enable, TIM1_OutputNState_Disable,               10, TIM1_OCPolarity_Low, TIM1_OCNPolarity_High, TIM1_OCIdleState_Set,               TIM1_OCNIdleState_Set);  TIM1_OC1PreloadConfig(DISABLE);    TIM1_ARRPreloadConfig(ENABLE);    /* Enable TIM1 outputs *///  TIM1_CtrlPWMOutputs(ENABLE);  //HalLightOpen();//  HalLightClose();//  HalLightSetBrightness(10);  HalLigthPWM = (80);  HalLightOpen();  }

/**  * @brief  Main program.  * @param  None  * @retval None  */void main(void){  /* Enable LSE */  CLK_LSEConfig(CLK_LSE_ON);  /* Wait for LSE clock to be ready */  while (CLK_GetFlagStatus(CLK_FLAG_LSERDY) == RESET);  /* wait for 1 second for the LSE Stabilisation */  LSE_StabTime();  /* Select LSE (32.768 KHz) as RTC clock source */  CLK_RTCClockConfig(CLK_RTCCLKSource_LSE, CLK_RTCCLKDiv_1);  CLK_PeripheralClockConfig(CLK_Peripheral_RTC, ENABLE);  /* Calendar Configuration */  Calendar_Init();  /*RTC Tamper Configuration*/  Tamper_Init();  /* EvalBoard Configuration */  EvalBoard_Init();  Tamper_DelayShow(TampFilterIndex);  while (1)  {    EnterSafeCode();    Time_Show(LCD_LINE2, SHOW_POINT2);    ExitSafeCode();  }}

/**  * @brief  Configure peripheral clock   * @param  None  * @retval None  */static void CLK_Config(void){  /* Select HSE as system clock source */  CLK_SYSCLKSourceSwitchCmd(ENABLE);  CLK_SYSCLKSourceConfig(CLK_SYSCLKSource_HSE);    /*High speed external clock prescaler: 1*/  CLK_SYSCLKDivConfig(CLK_SYSCLKDiv_2);  while (CLK_GetSYSCLKSource() != CLK_SYSCLKSource_HSE)  {}  /* Enable SPI clock */  CLK_PeripheralClockConfig(CLK_Peripheral_SPI1, ENABLE);  /* Enable DMA clock */  CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);}

//------------------------------------------------------------------------------// Function Name : delay_10us// Description   : delay for some time in 10us unit(partial accurate)// Input         : n_10us is how many 10us of time to delay//------------------------------------------------------------------------------void delay_1us(u16 n_1us){  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, ENABLE);  // Init TIMER 4 //  // prescaler: / (2^0) = /1  TIM4->PSCR = 0;#ifdef SYS_CLK_HSE_DIV1  // Auto-Reload value: 16M / 1 = 16M, 16M / 100k = 160  TIM4->ARR = 160;#else#ifdef SYS_CLK_HSE_DIV2  // Auto-Reload value: 16M/2 / 1 = 8M, 8M / 100k = 80  TIM4->ARR = 80;#else#ifdef SYS_CLK_HSI_DIV1  // Auto-Reload value: 16M / 1 = 16M, 16M / 100k = 160  TIM4->ARR = 16;#else#ifdef SYS_CLK_HSI_DIV2  // Auto-Reload value: 16M/2 / 1 = 8M, 8M / 100k = 80  TIM4->ARR = 80;#else#error "either SYS_CLK_HSE_DIV1/DIV2 or SYS_CLK_HSI_DIV1/DIV2 should be defined"#endif#endif#endif#endif  // Counter value: 10, to compensate the initialization of TIMER  TIM4->CNTR = 10;  // clear update flag  TIM4->SR1 &= ~TIM4_SR1_UIF;  // Enable Counter  TIM4->CR1 |= TIM4_CR1_CEN;  while (n_1us--)  {    while ((TIM4->SR1 & TIM4_SR1_UIF) == 0) ;    TIM4->SR1 &= ~TIM4_SR1_UIF;  }  // Disable Counter  TIM4->CR1 &= ~TIM4_CR1_CEN;  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, DISABLE);}

void InitTimer(void){  clk_config();  TIM2_DeInit();  CLK_PeripheralClockConfig(CLK_Peripheral_TIM2, ENABLE);  TIM2_TimeBaseInit(TIM2_Prescaler_1, TIM2_CounterMode_Up, 500);  TIM2_Cmd(ENABLE);}