目录

初始化

main.c 

main.h

led.c 

led.h 

key.c 

key.h 

tick.c

timer.c 

timer.h 

usart.c

usart.h

adc.c

adc.h

pwm.c 

pwm.h

i2c.c

pwm.c(simple out) 可调duty和frequency

pwm.c(simple input)可调duty和frequency

RTC.c

初始化

对STM32板上的基础模块的初始化，每次必须要用的一些基础模块如下：

main.c 

#include "main.h"
int main(void)
{
SysTick_Config(SystemCoreClock/1000);
Delay_Ms(10);
STM3210B_LCD_Init();
LCD_Clear(Black);
LCD_SetBackColor(Black);
LCD_SetTextColor(White);
while(1);
}

 main.h

#ifndef __MAIN_H
#define __MAIN_H
#include "stm32f10x.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "led.h"
#include "lcd.h"
#include "adc.h"
#include "tick.h"
#include "timer.h"
#include "key.h"
#include "usart.h"
#endif

led.c 

#include "led.h"
u8 ledstate=0x00;
void LEDInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOC, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOD, &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);
LEDcontrol(LEDALL,0);
}
void LEDcontrol(u8 LED,u8 state)
{
if(state==0){
GPIO_SetBits(GPIOC,LED);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
GPIO_ResetBits(GPIOD,GPIO_Pin_2);
}
else {
GPIO_ResetBits(GPIOC,LED);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
GPIO_ResetBits(GPIOD,GPIO_Pin_2);
}
}
void LEDswitch(u8 ledstate)
{
LEDcontrol(LEDALL,0);
LEDcontrol(8<<ledstate,1);
}

led.h 

#ifndef __LED_H
#define __LED_H
#include "main.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 0xff
void LEDInit(void);
void LEDcontrol(u8 LED,u8 state);
void LEDswitch(u8 ledstate);
extern u8 ledstate;
#endif

key.c 

#include "key.h"
void KEYInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
_Bool KEYflag=1;
u8 KEYScan(void)
{
if((!key1||!key2||!key3||!key4)&&KEYflag)
{
Delay_Ms(10);
KEYflag=0;
if
(key1==0) return 1;
else if(key2==0) return 2;
else if(key3==0) return 3;
else if(key4==0) return 4;
}
else if(key1==1&&key2==1&&key3==1&&key4==1)
{
KEYflag=1;
}
return 0;
}

key.h 

#ifndef __KEY_H
#define __KEY_H
#include "main.h"
extern _Bool KEYflag;
#define key1
GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
#define key2
GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8)
#define key3
GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)
#define key4
GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2)
void KEYInit(void);
u8 KEYScan(void);
#endif

tick.c

#include "tick.h"
u32 TimingDelay = 0;
void Delay_Ms(u32 nTime)
{
TimingDelay = nTime;
while(TimingDelay != 0);
}

timer.c 

#include "timer.h"
void TIM2Init(void)
{
TIM_TimeBaseInitTypeDef
TIM_TimeBaseStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
TIM_TimeBaseStructure.TIM_Period = 65535;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM2, ENABLE);
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);
}
void TIM2_IRQHandler(void)
{
if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
{
}
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
}

timer.h 

#ifndef __TIMER_H
#define __TIMER_H
#include "main.h"
void TIM2Init(void);
void TIM2_IRQHandler(void);
#endif

 usart.c

#include "usart.h"
uint8_t RxBuffer[20];
__IO uint8_t RxCounter=0 ;
_Bool RXflag=0;
void USART2Init(void)
{
USART_InitTypeDef USART_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 , ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);
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);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
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);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void USART2_IRQHandler(void)
{
char tmp = 0;
if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
{
tmp = USART_ReceiveData(USART2);
if( (RxCounter >= 1 && tmp == 'n' && RxBuffer[RxCounter-1] == 'r') || RxCounter >= 20)
{
RxBuffer[RxCounter-1] = 0;
USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
RXflag = 1;
}
else{
RxBuffer[RxCounter++] = tmp;
}
}
}
int fputc(int ch, FILE *f)
{
USART_SendData(USART2, (uint8_t) ch);
while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
return ch;
}

usart.h

#ifndef __USART_H
#define __USART_H
#include "main.h"
extern uint8_t RxBuffer[20];
extern __IO uint8_t RxCounter ;
extern _Bool RXflag;
void USART2Init(void);
int fputc(int ch, FILE *f);
#endif

adc.c

#include "adc.h"
void ADC1Init(void)
{
ADC_InitTypeDef
ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
//NVIC_InitTypeDef NVIC_InitStructure;
RCC_ADCCLKConfig(RCC_PCLK2_Div6);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_ADC1 , ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
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);
ADC_RegularChannelConfig(ADC1, ADC_Channel_14, 1, ADC_SampleTime_239Cycles5);
//多通道模式下把上面这个写到get（通道）函数里，然后加上software软件转换
//ADC_ITConfig(ADC1, ADC_IT_JEOC, ENABLE);
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
//	NVIC_InitStructure.NVIC_IRQChannel = ADC1_IRQn;
//	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
//	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
//	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//	NVIC_Init(&NVIC_InitStructure);
}
float Adc_GetVal(void)
{
float temp=0;
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
while(!ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC));
ADC_ClearFlag(ADC1,ADC_FLAG_EOC);
temp = ADC_GetConversionValue(ADC1)*3.3/4095;
return temp;
}

adc.h

#ifndef __ADC_H
#define __ADC_H
#include "main.h"
void ADC1Init(void);
float Adc_GetVal(void);
#endif

pwm.c 

#include "pwm.h"
u16 IC2Value = 0;
u16 IC3Value = 0;
u16 Frequency_1 = 0;
u16 Frequency_2 = 0;
//u16 DutyCycle = 0;
//u16 Frequency = 0;
u16 CCR1_Val=200;
u16 CCR1_ZKB=0.3;
void Timer2_PwmIn(void)
//void Timer3_PwmOut(u16 arr,u16 psc);
{
TIM_ICInitTypeDef
TIM_ICInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef
TIM_TimeBaseStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
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);
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
TIM_TimeBaseStructure.TIM_Period = 0xffff;
TIM_TimeBaseStructure.TIM_Prescaler = 71;
//psc
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_PWMIConfig(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_PWMIConfig(TIM2, &TIM_ICInitStructure);
//	TIM3CH1_set(0);
//
TIM3CH2_set(0);
//TIM_SelectInputTrigger(TIM2, TIM_TS_TI2FP2);
测频率要关掉，测占空比打开
TIM_SelectSlaveMode(TIM2, TIM_SlaveMode_Reset);
TIM_SelectMasterSlaveMode(TIM2, TIM_MasterSlaveMode_Enable);
TIM_Cmd(TIM2, ENABLE);
TIM_ITConfig(TIM2, TIM_IT_CC2|TIM_IT_CC3, ENABLE);
}
void TIM2_IRQHandler(void)
{
__IO uint16_t temp;
static __IO uint16_t IC1Value_temp,IC2Value_temp;
if(TIM_GetITStatus(TIM2, TIM_IT_CC2)!= RESET)
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
IC2Value = TIM_GetCapture2(TIM2);
temp = IC2Value - IC1Value_temp;
if(temp==0)
Frequency_1=0;
else{
Frequency_1 = SystemCoreClock/72/temp;
}
IC1Value_temp = IC2Value;
}
if(TIM_GetITStatus(TIM2, TIM_IT_CC3)!= RESET)
{
TIM_ClearITPendingBit(TIM2,TIM_IT_CC3);
IC3Value = TIM_GetCapture3(TIM2);
temp = IC3Value - IC2Value_temp;
if(temp==0)
Frequency_2=0;
else{
Frequency_2 = SystemCoreClock/72/temp;
}
IC2Value_temp = IC3Value;
}
//
void TIM3_IRQHandler(void)
//
TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
//
IC2Value = TIM_GetCapture1(TIM2);
//
if (IC2Value != 0)
//
{
//
DutyCycle = (TIM_GetCapture2(TIM3) * 100) / IC2Value;
//
Frequency = SystemCoreClock/72/IC2Value;
//
}
//
else
//
{
//
DutyCycle = 0;
//
Frequency = 0;
//
}
}
uint16_t capture = 0;
_Bool pa6_state=0,pa7_state=0;
void TIM3_IRQHandler(void)
{
if(TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM3);
if(pa6_state==0)
{
TIM_SetCompare1(TIM3,(u16)(capture + CCR1_Val*CCR1_ZKB));
pa6_state=1;
}
else if(pa6_state==1)
{
TIM_SetCompare1(TIM3,(u16)(capture + CCR1_Val*(1-CCR1_ZKB)));
pa6_state=0;
}
}
}
void TIM3CH1_set(u8 status)
{
TIM_OCInitTypeDef
TIM_OCInitStructure;
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
if(status)
{
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_ITConfig(TIM3, TIM_IT_CC1 , ENABLE);
}
else
{
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Disable;
TIM_ITConfig(TIM3, TIM_IT_CC1 , DISABLE);
}
TIM_OCInitStructure.TIM_Pulse = CCR1_Val;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
TIM_OC1Init(TIM3, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable);
}

pwm.h

#ifndef __PWM_H
#define __PWM_H
#include "main.h"
extern u16 IC2Value;
extern u16 IC3Value;
extern u16 Frequency_1;
extern u16 Frequency_2;
//extern u16 DutyCycle = 0;
//extern u16 Frequency = 0;
extern
u16
capture ;
extern _Bool pa6_state;
extern _Bool pa7_state;
extern u16 CCR1_Val;
extern u16 CCR1_ZKB;
void Timer2_PwmIn(void);
void TIM2_IRQHandler(void);
#endif

 i2c.c

void At24c02_U8write(u8 add,u8 data)
{
I2CStart();
I2CSendByte(0xa0);
I2CWaitAck();
I2CSendByte(add);
I2CWaitAck();
I2CSendByte(data);
I2CWaitAck();
I2CStop();
delay1(500);
}
void At24c02_U32write(u8 add,u32 data)
{
At24c02_U8write(add+0,(data>>0)&0xff);
At24c02_U8write(add+1,(data>>8)&0xff);
At24c02_U8write(add+2,(data>>16)&0xff);
At24c02_U8write(add+3,(data>>24)&0xff);
delay1(500);
}
u8 At24c02_U8read(u8 add)
{
u8 Tmp = 0;
I2CStart();
I2CSendByte(0xa0);
I2CWaitAck();
I2CSendByte(add);
I2CWaitAck();
I2CStart();
I2CSendByte(0xa1);
I2CWaitAck();
Tmp=I2CReceiveByte();
I2CStop();
delay1(500);
return Tmp;
}
u32 At24c02_U32read(u32 add)
{
u32 tmp=0;
tmp |=((u32)At24c02_U8read(add+0))<<0;
tmp |=((u32)At24c02_U8read(add+1))<<8;
tmp |=((u32)At24c02_U8read(add+2))<<16;
tmp |=((u32)At24c02_U8read(add+3))<<24;
delay1(500);
return tmp;
}

 pwm.c(simple out) 可调duty和frequency

#include "timer.h"
uint16_t CCR1_Val=2000;
uint16_t CCR2_Val=1000;
float CH1duty=0.3;
float CH2duty=0.6;
void TIM3_Init()
{
TIM_TimeBaseInitTypeDef
TIM_TimeBaseStructure;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
TIM_OCInitTypeDef
TIM_OCInitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_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;
//用timing无法软件仿真
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR1_Val;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC1Init(TIM3, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM3,TIM_OCPreload_Disable);
TIM_OCInitStructure.TIM_Pulse = CCR2_Val;
TIM_OC2Init(TIM3, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM3,TIM_OCPreload_Disable);
TIM_ITConfig(TIM3, TIM_IT_CC1 | TIM_IT_CC2 , ENABLE);
TIM_Cmd(TIM3, ENABLE);
GPIO_SetBits(GPIOA,GPIO_Pin_6 | GPIO_Pin_7 );
}
_Bool CH1flag=1;
_Bool CH2flag=1;
uint16_t capture=0;
void TIM3_IRQHandler(void)
{
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
capture = TIM_GetCapture1(TIM3);
if(CH1flag)
{
//看情况选择是否乘以2，会导致频率不一样
TIM_SetCompare1(TIM3, capture + (u16)(2*CCR1_Val*CH1duty));
CH1flag=0;
}
else
{
TIM_SetCompare1(TIM3, capture + (u16)(2*CCR1_Val*(1-CH1duty)));
CH1flag=1;
}
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
GPIO_WriteBit(GPIOA, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_6)));
}
else if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
capture = TIM_GetCapture2(TIM3);
if(CH2flag)
{
TIM_SetCompare1(TIM3, capture + (u16)(2*CCR2_Val*CH2duty));
CH2flag=0;
}
else
{
TIM_SetCompare1(TIM3, capture + (u16)(2*CCR2_Val*(1-CH2duty)));
CH2flag=1;
}
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_7)));
}
}

 pwm.c(simple input)可调duty和frequency

__IO uint16_t IC3ReadValue1 = 0, IC3ReadValue2 = 0;
__IO uint16_t CaptureNumber = 0;
__IO uint32_t Capture = 0;
__IO uint32_t TIM3Freq = 0;
void TIM3_inputInit()
{
TIM_TimeBaseInitTypeDef
TIM_TimeBaseStructure;
TIM_ICInitTypeDef
TIM_ICInitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_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_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(TIM3, &TIM_ICInitStructure);
/* TIM enable counter */
TIM_Cmd(TIM3, ENABLE);
/* Enable the CC2 Interrupt Request */
TIM_ITConfig(TIM3, TIM_IT_CC2, ENABLE);
//捕获频率和占空比
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_PWMIConfig(TIM3, &TIM_ICInitStructure);
TIM_SelectInputTrigger(TIM3, TIM_TS_TI2FP2); //CC2为主模式，则CC1就为从模式
TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Reset);
TIM_SelectMasterSlaveMode(TIM3, TIM_MasterSlaveMode_Enable);
TIM_Cmd(TIM3, ENABLE);
TIM_ITConfig(TIM3, TIM_IT_CC2, ENABLE);
}
//只捕获频率
void TIM3_IRQHandler(void)
{
if(TIM_GetITStatus(TIM3, TIM_IT_CC2) == SET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
if(CaptureNumber == 0)
{
IC3ReadValue1 = TIM_GetCapture2(TIM3);
CaptureNumber = 1;
}
else if(CaptureNumber == 1)
{
IC3ReadValue2 = TIM_GetCapture2(TIM3);
Capture = (uint16_t)(IC3ReadValue2 - IC3ReadValue1);
TIM3Freq = (uint32_t) SystemCoreClock / Capture;
CaptureNumber = 0;
}
}
}
//捕获频率和占空比
void TIM3_IRQHandler(void)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
IC2Value = TIM_GetCapture2(TIM3);
//TIM_GetCapture2是主模式
if (IC2Value != 0)
{
DutyCycle = (TIM_GetCapture1(TIM3) * 100) / IC2Value;
//TIM_GetCapture1是从模式
Frequency = SystemCoreClock / IC2Value;
}
else
{
DutyCycle = 0;
Frequency = 0;
}
}

RTC.c

#include "rtc.h"
u32 TimingDelay=0;
__IO uint32_t TimeDisplay = 0;
void Delay_Ms(u32 nTime)
{
TimingDelay=nTime;
while(TimingDelay != 0);
}
void RTC_Init()
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable PWR and BKP clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Reset Backup Domain */
BKP_DeInit();
/* Enable the LSI OSC */
RCC_LSICmd(ENABLE);
/* Wait till LSI is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
{}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
/* Enable RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC registers synchronization */
RTC_WaitForSynchro();
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Enable the RTC Second */
RTC_ITConfig(RTC_IT_SEC, ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Set RTC prescaler: set RTC period to 1sec */
RTC_SetPrescaler(40000);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* To output second signal on Tamper pin, the tamper functionality
must be disabled (by default this functionality is disabled) */
BKP_TamperPinCmd(DISABLE);
//
/* Enable the RTC Second Output on Tamper Pin */
//
BKP_RTCOutputConfig(BKP_RTCOutputSource_Second);
NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void Time_Adjust(uint32_t THH,uint32_t TMM,uint32_t TSS)
{
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Change the current time */
RTC_SetCounter(THH*3600+TMM*60+TSS);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/**
* @brief
Displays the current time.
* @param
TimeVar: RTC counter value.
* @retval None
*/
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() == 0x0001517F)
{
RTC_SetCounter(0x0);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/* Compute
hours */
THH = TimeVar / 3600;
/* Compute minutes */
TMM = (TimeVar % 3600) / 60;
/* Compute seconds */
TSS = (TimeVar % 3600) % 60;
printf("Time: %0.2d:%0.2d:%0.2dr", THH, TMM, TSS);
}
/**
* @brief
Shows the current time (HH:MM:SS) on the Hyperterminal.
* @param
None
* @retval None
*/
void Time_Show(void)
{
printf("nr");
/* Infinite loop */
while (1)
{
/* If 1s has been elapsed */
if (TimeDisplay == 1)
{
/* Display current time */
Time_Display(RTC_GetCounter());
TimeDisplay = 0;
}
}
}
void RTC_IRQHandler(void)
{
if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
{
RTC_ClearITPendingBit(RTC_IT_SEC);
TimeDisplay = 1;
RTC_WaitForLastTask();
}
}

最后

以上就是淡然萝莉最近收集整理的关于蓝桥杯基础模块初始化初始化main.c  main.hled.c led.h key.c key.h tick.ctimer.c timer.h  usart.cusart.hadc.cadc.hpwm.c pwm.h i2c.c pwm.c(simple out) 可调duty和frequency  pwm.c(simple input)可调duty和frequencyRTC.c的全部内容，更多相关蓝桥杯基础模块初始化初始化main.c  main.hled.c led.h key.c key.h tick.ctimer.c timer.h  usart.cusart.hadc.cadc.hpwm.c pwm.h i2c.c pwm.c(simple内容请搜索靠谱客的其他文章。