PY32F003F18之定时器中断

PY32F003F18定时器有TIM1，TIM3，TIM14，TIM16和TIM17。其中TIM1为高级定时器，其它为通用定时器。见下表：

一、PY32F003F18定时器的工作模式：

1、边沿对齐模式

计数器工作在"边沿对齐模式"
设置"TIMx控制寄存器1(TIMx_CR1)"的DIR和"TIMx控制寄存器1(TIMx_CR1)"的CMS[1:0]；
CMS[1:0]=00，配置TIMx为边沿对齐模式，当DIR=0时，计数器向上计数；当DIR=1时,计数器向下计数；

计数器使用"内部时钟源"：
如果从模式控制器被禁止，则CEN、DIR（TIMx_CR1 寄存器）和UG 位（TIMx_EGR 寄存器）是事实上的控制位，并且只能被软件修改。只要CEN 位被写成1，预分频器的时钟就由内部时钟CK_INT 提供。

2、中央对齐模式1

3、中央对齐模式2

4、中央对齐模式3
在中央对齐模式中，计数器从0开始计数到自动加载的值(TIMx_ARR 寄存器)，会产生一个计数器溢出事件；然后向下计数，
当计数器计数到1时，也会产生一个计数器下溢事件；然后再从0开始重新计数，这样循环往复开始计数。所以计数器中断时间不变。
计数器工作在"中央对齐模式"
设置"TIMx控制寄存器1(TIMx_CR1)"的CMS[1:0]；
1）、CMS[1:0]=01，配置TIMx为中央对齐模式1，计数器交替地向上和向下计数；若配置为输出通道的，则在计数器向下计数时,"OCx的输出比较中断标志位"被置1；
2）、CMS[1:0]=10，配置TIMx为中央对齐模式2，计数器交替地向上和向下计数；若配置为输出通道的，则在计数器向上计数时,"OCx的输出比较中断标志位"被置1；
3）、CMS[1:0]=11，配置TIMx为中央对齐模式3，计数器交替地向上和向下计数；若配置为输出通道的，则在计数器向上/向下计数时,"OCx的输出比较中断标志位"被置1；

计数器使用"内部时钟源"
如果从模式控制器被禁止，则CEN、DIR（TIMx_CR1 寄存器）和UG 位（TIMx_EGR 寄存器）是事实上
的控制位，并且只能被软件修改。只要CEN 位被写成1，预分频器的时钟就由内部时钟CK_INT 提供。

二、计数器使用内部时钟源的时序图

 三、测试程序

#include "TIM1_COUNTERMODE_UP.h"
#include "LED.h"
#include "MyTimer.h"/*
计数器工作在"边沿对齐模式"
//将"TIMx控制寄存器1(TIMx_CR1)"的DIR=0
//将"TIMx控制寄存器1(TIMx_CR1)"的CMS[1:0]=00B
//CMS[1:0]=00，配置TIMx为边沿对齐模式，当DIR=0时，计数器向上计数；当DIR=1时,计数器向下计数；计数器使用"内部时钟源"
如果从模式控制器被禁止，则CEN、DIR（TIMx_CR1 寄存器）和UG 位（TIMx_EGR 寄存器）是事实上
的控制位，并且只能被软件修改。只要CEN 位被写成1，预分频器的时钟就由内部时钟CK_INT 提供。
*/void TIM1_COUNTERMODE_UP_Init(uint16_t arr,uint16_t psc);//函数功能:TIM1中基本计数功能,并使能了更新中断,每次重装ARR值时会产生一次更新中断
//arr：自动重装值。
//psc：时钟预分频数
//TIM1_COUNTERMODE_UP_Init(20000,240);//若使用HSE，当arr=20000,psc=240时,则为200ms,误差为10us;
//TIM1_COUNTERMODE_UP_Init(20000,80);//若使用HSI，当arr=20000,psc=80时,则为200ms,误差为10us;
void TIM1_COUNTERMODE_UP_Init(uint16_t arr,uint16_t psc)
{TIM_Base_InitTypeDef TIM_Base_InitStructure;
//	TIM_HandleTypeDef  TIM1_HandleStructure;__HAL_RCC_TIM1_CLK_ENABLE(); //使能TIM1时钟HAL_NVIC_SetPriority(TIM1_BRK_UP_TRG_COM_IRQn, 0, 0); //设置中断优先级HAL_NVIC_EnableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);         //使能TIM1中断TIM_Base_InitStructure.Period            = arr-1;//设置在下一个更新事件产生时，装入"自动重载入寄存器TIMx_ARR"的值//将(1600 - 1)写入"自动重载入寄存器TIMx_ARR",设置自动重装载值TIM_Base_InitStructure.Prescaler         = psc-1;//设置用来作为TIMx时钟频率除数的预分频值//将(1000-1)写入"预装载寄存器TIMx_PSC",的PSC[15:0],设置预分频值//计数器的时钟频率CK_CNT=fCK_PSC/(PSC[15:0]+1)TIM_Base_InitStructure.ClockDivision = TIM_CLOCKDIVISION_DIV1; //时钟不分频,则tDTS=tCK_INT//若使用HSE，计算公式:arr*psc/24000000/1,当arr=20000,psc=240时,则为200ms,误差为10us;//若使用HSI，计算公式:arr*psc/8000000/1,当arr=20000,psc=80时,则为200ms,误差为100us;TIM_Base_InitStructure.CounterMode   = TIM_COUNTERMODE_UP;     //计数器向上计数TIM_Base_InitStructure.RepetitionCounter = 1 - 1;//不重复计数//将(1-1)写入"重复计数寄存器TIMx_RCR"中的REP[7:0],设置"重复计数器值"TIM_Base_InitStructure.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;//"自动重装载寄存器"没有缓冲//不允许将"TIMx自动重新加载寄存器TIMx_ARR"的值被装入缓冲区;TIM_Base_SetConfig(TIM1,&TIM_Base_InitStructure);//选择计数器模式:向上计数//设置时钟分频因子:时钟不分频,则tDTS=tCK_INT//设置自动重装载:"自动重装载寄存器"没有缓冲//设置自动重装载值:TIM_Base_InitStructure.Period//设置预分频值:TIM_Base_InitStructure.Prescaler//设置"重复计数器值":TIM_Base_InitStructure.RepetitionCounter//启动更新事件:将TIMx_EGR中的UG位置1,由软件产生更新事件_HAL_TIM_ENABLE_IT(TIM1, TIM_IT_UPDATE);//将"TIMx DMA/中断使能寄存器TIM3_DIER"的UIE=1,允许计数器更新产生中断_HAL_TIM_ENABLE(TIM1);//计数器使能,开始计数//  TIM1_HandleStructure.Instance = TIM1; 
//	HAL_TIM_Base_Start_IT(&TIM1_HandleStructure);//TIM1使能启动,开始计数,并使能中断
}//函数功能:定时器中断服务程序
//200ms中断一次
void TIM1_BRK_UP_TRG_COM_IRQHandler(void)
{if (_HAL_TIM_GET_FLAG(TIM1,TIM_FLAG_UPDATE) != RESET){//计数器更新事件if (_HAL_TIM_GET_IT_SOURCE(TIM1, TIM_IT_UPDATE) != RESET){_HAL_TIM_CLEAR_IT(TIM1, TIM_IT_UPDATE);MCU_LED_Toggle();}}
}
#ifndef __MyTimer_H
#define __MyTimer_H#include "py32f0xx_hal.h"#define _HAL_TIM_ENABLE(__INSTANCE__)                 ((__INSTANCE__)->CR1|=(TIM_CR1_CEN))
//计数器使能,开始计数#define _HAL_TIM_DISABLE(__INSTANCE__) \do { \if (((__INSTANCE__)->CCER & TIM_CCER_CCxE_MASK) == 0UL) \{ \if(((__INSTANCE__)->CCER & TIM_CCER_CCxNE_MASK) == 0UL) \{ \(__INSTANCE__)->CR1 &= ~(TIM_CR1_CEN); \} \} \} while(0)
//计数器不使能,停止计数#define _HAL_TIM_MOE_ENABLE(__INSTANCE__)             ((__INSTANCE__)->BDTR|=(TIM_BDTR_MOE))
//将"TIMx刹车和死区寄存器(TIMx_BDTR)"中的MOE=1,开启OCx和OCxN输出,即使能"TIMx_CH1和TIMx_CH1N"输出#define _HAL_TIM_MOE_DISABLE_UNCONDITIONALLY(__INSTANCE__)  (__INSTANCE__)->BDTR &= ~(TIM_BDTR_MOE)
//将"TIMx刹车和死区寄存器(TIMx_BDTR)"中的MOE=0,关闭OCx和OCxN输出,即不使能"TIMx_CH1和TIMx_CH1N"输出#define _HAL_TIM_MOE_DISABLE(__INSTANCE__) \do { \if (((__INSTANCE__)->CCER & TIM_CCER_CCxE_MASK) == 0UL) \{ \if(((__INSTANCE__)->CCER & TIM_CCER_CCxNE_MASK) == 0UL) \{ \(__INSTANCE__)->BDTR &= ~(TIM_BDTR_MOE); \} \} \} while(0)
//在"TIMx捕获/比较使能寄存器TIMx_CCER"中,如果"OCx禁止输出或捕获禁止",且"OCxNE禁止输出"
//则将"TIMx刹车和死区寄存器(TIMx_BDTR)"中的MOE=0,关闭OCx和OCxN输出,即不使能"TIMx_CH1和TIMx_CH1N"输出#define _HAL_TIM_ENABLE_IT(__INSTANCE__, __INTERRUPT__)    ((__INSTANCE__)->DIER |= (__INTERRUPT__))
//根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIM3_DIER)的对应位置1，使能相应的中断
//TIM_IT_UPDATE,允许定时器更新中断,UIE=1
//TIM_IT_CC1,允许捕获/比较1中断,CC1IE=1
//TIM_IT_CC2,允许捕获/比较2中断,CC2IE=1
//TIM_IT_CC3,允许捕获/比较3中断,CC3IE=1
//TIM_IT_CC4,允许捕获/比较4中断,CC4IE=1
//TIM_IT_COM,允许COM事件中断,COMIE=1
//TIM_IT_TRIGGER,允许触发中断,TIE=1
//TIM_IT_BREAK,允许刹车中断,BIE=1#define _HAL_TIM_DISABLE_IT(__INSTANCE__, __INTERRUPT__)   ((__INSTANCE__)->DIER &= ~(__INTERRUPT__))
//根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIM3_DIER)的对应位清除，不使能相应的中断
//TIM_IT_UPDATE,禁止定时器更新中断,UIE=0
//TIM_IT_CC1,禁止捕获/比较1中断,CC1IE=0
//TIM_IT_CC2,禁止捕获/比较2中断,CC2IE=0
//TIM_IT_CC3,禁止捕获/比较3中断,CC3IE=0
//TIM_IT_CC4,禁止捕获/比较4中断,CC4IE=0
//TIM_IT_COM,禁止COM事件中断,COMIE=0
//TIM_IT_TRIGGER,禁止触发中断,TIE=0
//TIM_IT_BREAK,禁止刹车中断,BIE=0#define _HAL_TIM_ENABLE_DMA(__INSTANCE__, __DMA__)         ((__INSTANCE__)->DIER |= (__DMA__))
//根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIMx_DIER)的对应位置1，使能相应的DMA请求
//TIM_DMA_UPDATE,允许更新的DMA请求,UDE=1
//TIM_DMA_CC1,允许捕获/比较1的DMA请求,CC1DE=1
//TIM_DMA_CC2,允许捕获/比较2的DMA请求,CC2DE=1
//TIM_DMA_CC3,允许捕获/比较3的DMA请求,CC3DE=1
//TIM_DMA_CC4,允许捕获/比较4的DMA请求,CC4DE=1
//TIM_DMA_COM,允许COM的DMA请求,COMDE=1
//TIM_DMA_TRIGGER,允许触发DMA请求,TDE=1#define _HAL_TIM_DISABLE_DMA(__INSTANCE__, __DMA__)        ((__INSTANCE__)->DIER &= ~(__DMA__))
//根据__INTERRUPT__，将TIMx DMA/中断使能寄存器(TIMx_DIER)的对应位置1，不使能相应的DMA请求
//TIM_DMA_UPDATE,禁止更新的DMA请求,UDE=0
//TIM_DMA_CC1,禁止捕获/比较1的DMA请求,CC1DE=0
//TIM_DMA_CC2,禁止捕获/比较2的DMA请求,CC2DE=0
//TIM_DMA_CC3,禁止捕获/比较3的DMA请求,CC3DE=0
//TIM_DMA_CC4,禁止捕获/比较4的DMA请求,CC4DE=0
//TIM_DMA_COM,禁止COM的DMA请求,COMDE=0
//TIM_DMA_TRIGGER,禁止触发DMA请求,TDE=0#define _HAL_TIM_GET_FLAG(__INSTANCE__, __FLAG__)          (((__INSTANCE__)->SR &(__FLAG__)) == (__FLAG__))
//根据__FLAG__,若"TIMx状态寄存器(TIMx_SR)"中相应的位置1,则返回1
//TIM_FLAG_UPDATE,若UIF=1,建立"更新事件"
//TIM_FLAG_CC1,若CC1IF=1,如果通道CC1配置为输出模式，则建立"CC1输出事件"；
//TIM_FLAG_CC1,若CC1IF=1,如果通道CC1配置为输入模式，则建立"CC1捕获事件"
//TIM_FLAG_CC2,若CC2IF=1,如果通道CC2配置为输出模式，则建立"CC2输出事件"；
//TIM_FLAG_CC2,若CC2IF=1,如果通道CC2配置为输入模式，则建立"CC2捕获事件"
//TIM_FLAG_CC3,若CC3IF=1,如果通道CC3配置为输出模式，则建立"CC3输出事件"；
//TIM_FLAG_CC3,若CC3IF=1,如果通道CC3配置为输入模式，则建立"CC3捕获事件"
//TIM_FLAG_CC4,若CC4IF=1,如果通道CC4配置为输出模式，则建立"CC4输出事件"；
//TIM_FLAG_CC4,若CC4IF=1,如果通道CC4配置为输入模式，则建立"CC4捕获事件"；
//TIM_FLAG_COM，若COMIF=1，则建立"COM事件"
//TIM_FLAG_TRIGGER，若TIF=1，则建立"触发事件"
//TIM_FLAG_BREAK,若BIF=1,则建立"刹车事件"
//TIM_FLAG_CC1OF,若CC1OF=1,则表示"计数器x的值被捕获到TIMx_CCR1寄存器"
//TIM_FLAG_CC2OF,若CC2OF=1,则表示"计数器x的值被捕获到TIMx_CCR2寄存器"
//TIM_FLAG_CC3OF,若CC3OF=1,则表示"计数器x的值被捕获到TIMx_CCR3寄存器"
//TIM_FLAG_CC4OF,若CC4OF=1,则表示"计数器x的值被捕获到TIMx_CCR4寄存器"#define _HAL_TIM_CLEAR_FLAG(__INSTANCE__, __FLAG__)        ((__INSTANCE__)->SR = ~(__FLAG__))
//这么写的原因,因为定时器只能做某一种功能,不能同时实现多种功能
//根据__FLAG__,若"TIMx状态寄存器(TIMx_SR)"中相应的位置0,则返回1
//TIM_FLAG_UPDATE,若UIF=1,建立"更新事件"
//TIM_FLAG_CC1,令CC1IF=0,如果通道CC1配置为输出模式，则清除"CC1输出事件"；
//TIM_FLAG_CC1,令CC1IF=0,如果通道CC1配置为输入模式，则清除"CC1捕获事件"
//TIM_FLAG_CC2,令CC2IF=0,如果通道CC2配置为输出模式，则清除"CC2输出事件"；
//TIM_FLAG_CC2,令CC2IF=0,如果通道CC2配置为输入模式，则清除"CC2捕获事件"
//TIM_FLAG_CC3,令CC3IF=0,如果通道CC3配置为输出模式，则清除"CC3输出事件"；
//TIM_FLAG_CC3,令CC3IF=0,如果通道CC3配置为输入模式，则清除"CC3捕获事件"
//TIM_FLAG_CC4,令CC4IF=0,如果通道CC4配置为输出模式，则清除"CC4输出事件"；
//TIM_FLAG_CC4,令CC4IF=0,如果通道CC4配置为输入模式，则清除"CC4捕获事件"；
//TIM_FLAG_COM，令COMIF=0，则清除"COM事件"
//TIM_FLAG_TRIGGER，令TIF=0，则清除"触发事件"
//TIM_FLAG_BREAK,令BIF=0,则清除"刹车事件"
//TIM_FLAG_CC1OF,令CC1OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR1寄存器)
//TIM_FLAG_CC2OF,令CC2OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR2寄存器)
//TIM_FLAG_CC3OF,令CC3OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR3寄存器)
//TIM_FLAG_CC4OF,令CC4OF=0,则清除建立的事件(计数器x的值被捕获到TIMx_CCR4寄存器)#define _HAL_TIM_GET_IT_SOURCE(__INSTANCE__, __INTERRUPT__) ((((__INSTANCE__)->DIER & (__INTERRUPT__)) \== (__INTERRUPT__)) ? SET : RESET)
//根据__INTERRUPT__,若"TIMx DMA/中断使能寄存器(TIM3_DIER)的对应位置1,则返回1
//TIM_IT_UPDATE,若UIE=1，返回1,当前允许定时器更新中断
//TIM_IT_CC1,若CC1IE=1，返回1,当前允许捕获/比较1中断
//TIM_IT_CC2,若CC2IE=1，返回1,当前允许捕获/比较2中断
//TIM_IT_CC3,若CC3IE=1，返回1,当前允许捕获/比较3中断
//TIM_IT_CC4,若CC4IE=1，返回1,当前允许捕获/比较4中断
//TIM_IT_COM,若COMIE=1，返回1,当前允许COM事件中断
//TIM_IT_TRIGGER,若TIE=1，返回1,当前允许触发中断
//TIM_IT_BREAK,若BIE=1,返回1,当前允许刹车中断#define _HAL_TIM_CLEAR_IT(__INSTANCE__, __INTERRUPT__)      ((__INSTANCE__)->SR = ~(__INTERRUPT__))
//根据__INTERRUPT__,将"TIMx状态寄存器(TIMx_SR)"中相应的位置0,取消中断标志位
//TIM_IT_UPDATE,令UIE=0，不允许定时器更新中断
//TIM_IT_CC1,令CC1IE=0，不允许捕获/比较1中断
//TIM_IT_CC2,令CC2IE=0，不允许捕获/比较2中断
//TIM_IT_CC3,令CC3IE=0，不允许捕获/比较3中断
//TIM_IT_CC4,令CC4IE=0，不允许捕获/比较4中断
//TIM_IT_COM,令COMIE=0，不允许COM事件中断
//TIM_IT_TRIGGER,令TIE=0，不允许触发中断
//TIM_IT_BREAK,令BIE=0,不允许刹车中断#define _HAL_TIM_IS_TIM_COUNTING_DOWN(__INSTANCE__)    (((__INSTANCE__)->CR1 &(TIM_CR1_DIR)) == (TIM_CR1_DIR))
//读"TIMx控制寄存器1(TIMx_CR1)"的DIR位,若返回值为1,则表示该计数器为向下计数；否则为向上计数#define _HAL_TIM_SET_PRESCALER(__INSTANCE__, __PRESC__)       ((__INSTANCE__)->PSC = (__PRESC__))
//将(__PRESC__)写入"预装载寄存器TIMx_PSC",的PSC[15:0],设置预分频值
//计数器的时钟频率CK_CNT=fCK_PSC/(PSC[15:0]+1)#define _HAL_TIM_SET_COUNTER(__INSTANCE__, __COUNTER__)  ((__INSTANCE__)->CNT = (__COUNTER__))
//将(__COUNTER__)的值写入"TIMx计数器(TIMx_CNT)"#define _HAL_TIM_GET_COUNTER(__INSTANCE__)  ((__INSTANCE__)->CNT)
//读"TIMx计数器(TIMx_CNT)"的值#define _HAL_TIM_SET_AUTORELOAD(__INSTANCE__, __AUTORELOAD__) \do{                                                    \(__INSTANCE__)->ARR = (__AUTORELOAD__);  \} while(0)
//将(__AUTORELOAD__)写入"自动重载入寄存器TIMx_ARR",设置自动重装载值#define _HAL_TIM_GET_AUTORELOAD(__INSTANCE__)  ((__INSTANCE__)->ARR)
//从"自动重载入寄存器TIMx_ARR"中,读取"自动重装载值"#define _HAL_TIM_SET_CLOCKDIVISION(__INSTANCE__, __CKD__) \do{                                                   \(__INSTANCE__)->CR1 &= (~TIM_CR1_CKD);  \(__INSTANCE__)->CR1 |= (__CKD__);       \} while(0)
//设置"时钟分频因子"
//将TIM1控制寄存器1(TIM1_CR1)的CKD[1:0]置00B
//TIM_CLOCKDIVISION_DIV1,则(__CKD__)=00B：时钟分频因子tDTS=tCK_INT
//TIM_CLOCKDIVISION_DIV2,则((__CKD__)=01B：时钟分频因子tDTS=2*tCK_INT
//TIM_CLOCKDIVISION_DIV4,则((__CKD__)=10B：时钟分频因子tDTS=4*tCK_INT#define _HAL_TIM_GET_CLOCKDIVISION(__INSTANCE__)  ((__INSTANCE__)->CR1 & TIM_CR1_CKD)
//从"TIMx控制寄存器1(TIM1_CR1)"中,读取CKD[1:0]位值,就是"时钟分频因子"
//将TIM1控制寄存器1(TIM1_CR1)的CKD[1:0]置00B
//返回值为TIM_CLOCKDIVISION_DIV1,表示时钟分频因子tDTS=tCK_INT
//返回值为TIM_CLOCKDIVISION_DIV2,表示时钟分频因子tDTS=2*tCK_INT
//返回值为TIM_CLOCKDIVISION_DIV4,表示时钟分频因子tDTS=4*tCK_INT#define TIMx_RESET_ICPRESCALERVALUE(__INSTANCE__, __CHANNEL__) \( ( (__CHANNEL__) == TIM_CHANNEL_1) ? ( (__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_IC1PSC ) :\( (__CHANNEL__) == TIM_CHANNEL_2) ? ( (__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_IC2PSC ) :\( (__CHANNEL__) == TIM_CHANNEL_3) ? ( (__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_IC3PSC ) :\( (__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_IC4PSC ) )
//设置"输入捕获模式，Input Capture mode"
//如果(__CHANNEL__)为TIM_CHANNEL_1，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
//如果(__CHANNEL__)为TIM_CHANNEL_2，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
//如果(__CHANNEL__)为TIM_CHANNEL_3，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]#define TIMx_SET_ICPRESCALERVALUE(__INSTANCE__, __CHANNEL__, __ICPSC__) \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 |= (__ICPSC__)) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 |= ((__ICPSC__) << 8U)) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 |= (__ICPSC__)) :\((__INSTANCE__)->CCMR2 |= ((__ICPSC__) << 8U)))
//设置"输入捕获模式，Input Capture mode"
//若(__CHANNEL__)=TIM_CHANNEL_1，则用(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
//若(__CHANNEL__)=TIM_CHANNEL_2，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
//若(__CHANNEL__)=TIM_CHANNEL_3，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]#define _HAL_TIM_GET_ICPRESCALER(__INSTANCE__, __CHANNEL__)  \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 & TIM_CCMR1_IC1PSC) :\((__CHANNEL__) == TIM_CHANNEL_2) ? (((__INSTANCE__)->CCMR1 & TIM_CCMR1_IC2PSC) >> 8U) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 & TIM_CCMR2_IC3PSC) :\(((__INSTANCE__)->CCMR2 & TIM_CCMR2_IC4PSC)) >> 8U)
//在"输入捕获模式"中,
//若(__CHANNEL__)=TIM_CHANNEL_1，则读取"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
//若(__CHANNEL__)=TIM_CHANNEL_2，则读取"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
//若(__CHANNEL__)=TIM_CHANNEL_3，则读取"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]#define _HAL_TIM_SET_COMPARE(__INSTANCE__, __CHANNEL__, __COMPARE__) \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCR1 = (__COMPARE__)) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCR2 = (__COMPARE__)) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCR3 = (__COMPARE__)) :\((__INSTANCE__)->CCR4 = (__COMPARE__)))
//设置"CCx的预装载值"：
//若(__CHANNEL__)=TIM_CHANNEL_1，则将(__COMPARE__)写入TIMx捕获/比较寄存器1(TIMx_CCR1)中的CCR1[15:0],表示预装载值
//若(__CHANNEL__)=TIM_CHANNEL_2，则将(__COMPARE__)写入TIMx捕获/比较寄存器2(TIMx_CCR2)中的CCR2[15:0],表示预装载值
//若(__CHANNEL__)=TIM_CHANNEL_3，则将(__COMPARE__)写入TIMx捕获/比较寄存器3(TIMx_CCR3)中的CCR3[15:0],表示预装载值
//若(__CHANNEL__)=TIM_CHANNEL_4，则将(__COMPARE__)写入TIMx捕获/比较寄存器4(TIMx_CCR4)中的CCR3[15:0],表示预装载值#define _HAL_TIM_GET_COMPARE(__INSTANCE__, __CHANNEL__) \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCR1) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCR2) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCR3) :\((__INSTANCE__)->CCR4))
//读取"CCx的预装载值"：
//若(__CHANNEL__)=TIM_CHANNEL_1，则从TIMx捕获/比较寄存器1(TIMx_CCR1)中的CCR1[15:0]读取预装载值
//若(__CHANNEL__)=TIM_CHANNEL_2，则从TIMx捕获/比较寄存器2(TIMx_CCR2)中的CCR2[15:0]读取预装载值
//若(__CHANNEL__)=TIM_CHANNEL_3，则从TIMx捕获/比较寄存器3(TIMx_CCR3)中的CCR3[15:0]读取预装载值
//若(__CHANNEL__)=TIM_CHANNEL_4，则从TIMx捕获/比较寄存器3(TIMx_CCR4)中的CCR3[15:0]读取预装载值#define _HAL_TIM_ENABLE_OCxPRELOAD(__INSTANCE__, __CHANNEL__)    \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC1PE) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC2PE) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC3PE) :\((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC4PE))
//开启TIMx_CCRy寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1PE位置1，开启TIMx_CCR1寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2PE位置1，开启TIMx_CCR2寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3PE位置1，开启TIMx_CCR3寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4PE位置1，开启TIMx_CCR4寄存器的预装载功能#define _HAL_TIM_DISABLE_OCxPRELOAD(__INSTANCE__, __CHANNEL__)    \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC1PE) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC2PE) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC3PE) :\((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC4PE))
//禁止TIMx_CCRy寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1PE位置0，禁止TIMx_CCR1寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2PE位置0，禁止TIMx_CCR2寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3PE位置0，禁止TIMx_CCR3寄存器的预装载功能
//若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4PE位置0，禁止TIMx_CCR4寄存器的预装载功能#define _HAL_TIM_ENABLE_OCxFAST(__INSTANCE__, __CHANNEL__)    \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC1FE) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 |= TIM_CCMR1_OC2FE) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC3FE) :\((__INSTANCE__)->CCMR2 |= TIM_CCMR2_OC4FE))
//开启"比较x快速输出"功能，加快CCx输出对触发器x输入事件的响应
//若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1FE位置1，开启"比较1快速输出"功能
//若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2FE位置1，开启"比较2快速输出"功能
//若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3FE位置1，开启"比较3快速输出"功能
//若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4FE位置1，开启"比较4快速输出"功能#define _HAL_TIM_DISABLE_OCxFAST(__INSTANCE__, __CHANNEL__)    \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC1FE) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCMR1 &= ~TIM_CCMR1_OC2FE) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC3FE) :\((__INSTANCE__)->CCMR2 &= ~TIM_CCMR2_OC4FE))
//禁止"比较x快速输出"功能，不用加快CC输出对触发器输入事件的响应
//若(__CHANNEL__)=TIM_CHANNEL_1，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC1FE位置0，禁止"比较1快速输出"功能
//若(__CHANNEL__)=TIM_CHANNEL_2，则将"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的OC2FE位置0，禁止"比较2快速输出"功能
//若(__CHANNEL__)=TIM_CHANNEL_3，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC3FE位置0，禁止"比较3快速输出"功能
//若(__CHANNEL__)=TIM_CHANNEL_4，则将"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的OC4FE位置0，禁止"比较4快速输出"功能#define _HAL_TIM_URS_ENABLE(__INSTANCE__)  ((__INSTANCE__)->CR1|= TIM_CR1_URS)
//将"TIMx控制寄存器1(TIM1_CR1)"中的URS位置1
//允许在"计数器溢出/下溢"时,产生一个更新中断或DMA请求;#define _HAL_TIM_URS_DISABLE(__INSTANCE__)  ((__INSTANCE__)->CR1&=~TIM_CR1_URS)
//将"TIMx控制寄存器1(TIM1_CR1)"中的URS位置0
//允许在"计数器溢出/下溢"时,产生一个更新中断或DMA请求;
//允许在"TIMx_EGR中的UG位置1"时,产生一个更新中断或DMA请求;
//允许在"从模式控制器产生更新"时,产生一个更新中断或DMA请求;#define _HAL_TIM_SET_ICPRESCALER(__INSTANCE__, __CHANNEL__, __ICPSC__) \do{                                                    \TIMx_RESET_ICPRESCALERVALUE((__INSTANCE__), (__CHANNEL__));  \TIMx_SET_ICPRESCALERVALUE((__INSTANCE__), (__CHANNEL__), (__ICPSC__)); \} while(0)
//使用(__ICPSC__)设置通道为(__CHANNEL__)的"输入捕获预分频器"的值
//设置"输入捕获模式，Input Capture mode"
//如果(__CHANNEL__)为TIM_CHANNEL_1，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
//如果(__CHANNEL__)为TIM_CHANNEL_2，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
//如果(__CHANNEL__)为TIM_CHANNEL_3，则清除"TIMx捕获/比较模式寄存器1(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]
//设置"输入捕获模式，Input Capture mode"
//若(__CHANNEL__)=TIM_CHANNEL_1，则用(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获1预分频器C1PSC[1:0]
//若(__CHANNEL__)=TIM_CHANNEL_2，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器1(TIMx_CCMR1)"中的输入/捕获2预分频器C2PSC[1:0]
//若(__CHANNEL__)=TIM_CHANNEL_3，则(__ICPSC__)设置"TIMx捕获/比较模式寄存器2(TIMx_CCMR2)"中的输入/捕获3预分频器C3PSC[1:0]#define TIMx_RESET_CAPTUREPOLARITY(__INSTANCE__, __CHANNEL__) \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC1P | TIM_CCER_CC1NP)) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC2P | TIM_CCER_CC2NP)) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCER &= ~(TIM_CCER_CC3P | TIM_CCER_CC3NP)) :\((__INSTANCE__)->CCER &= ~(TIM_CCER_CC4P | TIM_CCER_CC4NP)))
//设置"输入/捕获x的输出极性"
//TIMx捕获/比较使能寄存器(TIMx_CCER)
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=0；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=0；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=0；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=0；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=0；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=0；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=0；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=0；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效#define TIMx_SET_CAPTUREPOLARITY(__INSTANCE__, __CHANNEL__, __POLARITY__) \(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__INSTANCE__)->CCER |= (__POLARITY__)) :\((__CHANNEL__) == TIM_CHANNEL_2) ? ((__INSTANCE__)->CCER |= ((__POLARITY__) << 4U)) :\((__CHANNEL__) == TIM_CHANNEL_3) ? ((__INSTANCE__)->CCER |= ((__POLARITY__) << 8U)) :\((__INSTANCE__)->CCER |= (((__POLARITY__) << 12U))))
//设置"输入/捕获x的输出极性"
//TIMx捕获/比较使能寄存器(TIMx_CCER)
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=1；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=1；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=1；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=1；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=1；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=1；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=1；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=1；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效#define _HAL_TIM_SET_CAPTUREPOLARITY(__INSTANCE__, __CHANNEL__, __POLARITY__)    \do{                                                                     \TIMx_RESET_CAPTUREPOLARITY((__INSTANCE__), (__CHANNEL__));               \TIMx_SET_CAPTUREPOLARITY((__INSTANCE__), (__CHANNEL__), (__POLARITY__)); \}while(0)
//设置"输入/捕获x的输出极性"
//TIMx捕获/比较使能寄存器(TIMx_CCER)
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=0；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=0；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=0；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=0；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=0；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=0；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=0；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=0；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效
//设置"输入/捕获x的输出极性"
//TIMx捕获/比较使能寄存器(TIMx_CCER)
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1P时,令CC1P=1；CC1P=0表示"输入/捕获1输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_1,(__POLARITY__)=TIM_CCER_CC1NP时,令CC1NP=1；CC1NP=0表示"输入/捕获1互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2P时,令CC2P=1；CC2P=0表示"输入/捕获2输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_2,(__POLARITY__)=TIM_CCER_CC2NP时,令CC2NP=1；CC2NP=0表示"输入/捕获2互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3P时,令CC3P=1；CC3P=0表示"输入/捕获3输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_3,(__POLARITY__)=TIM_CCER_CC3NP时,令CC3NP=1；CC3NP=0表示"输入/捕获3互补输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4P时,令CC4P=1；CC4P=0表示"输入/捕获4输出极性"为高电平有效，否则为低电平有效
//当(__CHANNEL__)=TIM_CHANNEL_4,(__POLARITY__)=TIM_CCER_CC4NP时,令CC4NP=1；CC4NP=0表示"输入/捕获4互补输出极性"为高电平有效，否则为低电平有效	
#endif /* __MyTimer_H */
#include "py32f0xx_hal.h"
#include "SystemClock.h"
#include "USART2.h"
#include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
#include "string.h" //使能strcpy(),strlen(),memset()
#include "delay.h"
#include "LED.h"
#include "TIM1_COUNTERMODE_UP.h"
#include "SystemClock.h"const char CPU_Reset_REG[]="\r\nCPU reset!\r\n";
int main(void)
{HSE_Config();HAL_Init();//systick初始化delay_init();HAL_Delay(1000);MCU_LED_Init();USART2_Init(115200);printf("%s",CPU_Reset_REG);TIM1_COUNTERMODE_UP_Init(20000,240);//若使用HSE，当arr=20000,psc=240时,则为200ms,误差为10us;
//	TIM1_COUNTERMODE_UP_Init(20000,80);//若使用HSI，当arr=20000,psc=80时,则为200ms,误差为10us;while (1){delay_ms(100);}
}
#include "SystemClock.h"
#include "py32f0xx_hal.h"void HSE_Config(void);
void HSI_Config(void);//函数功能:初始化"HSI,HSE,LSI振荡器",HSE用作系统时钟(SYSCLK),同时配置"AHB时钟(HCLK)和APB时钟(PCLK)"
void HSE_Config(void)
{HAL_StatusTypeDef retData;RCC_OscInitTypeDef RCC_OscInitStruct = {0};RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};//配置HSE,HSI和LSI振荡器RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_LSI;RCC_OscInitStruct.HSIState = RCC_HSI_ON; //开启HSIRCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1; //HSI不分频
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_4MHz;    //配置HSI输出时钟为4MHzRCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_8MHz;      //配置HSI输出时钟为8MHz
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_16MHz;   //配置HSI输出时钟为16MHz
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_22p12MHz;//配置HSI输出时钟为22.12MHz
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_24MHz;   //配置HSI输出时钟为24MHzRCC_OscInitStruct.HSEState = RCC_HSE_ON;      //开启HSERCC_OscInitStruct.HSEFreq = RCC_HSE_16_32MHz; //HSE工作频率范围16M~32MRCC_OscInitStruct.LSIState = RCC_LSI_ON;      //开启LSIretData=HAL_RCC_OscConfig(&RCC_OscInitStruct);//初始化HSI,HSE,LSI振荡器if ( retData!= HAL_OK)//初始化振荡器失败{}//初始化"系统时钟(SYSCLK),AHB时钟(HCLK)和APB时钟(PCLK)"RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;//SYSCLK的源选择为HSERCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;//AHB时钟(HCLK)不分频,输出为APB时钟RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2; //APB时钟(PCLK)分频器为2分频,输出为PCLK时钟retData=HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);//初始化RCC系统时钟(小于24MHz,则使用FLASH_LATENCY_0;大于24MHz且小于48MHz,则使用FLASH_LATENCY_1)if ( retData!= HAL_OK)//初始化RCC系统时钟失败{}
}//函数功能:初始化"HSI振荡器",用作系统时钟(SYSCLK),同时配置"AHB时钟(HCLK)和APB时钟(PCLK)"
void HSI_Config(void)
{HAL_StatusTypeDef retData;RCC_OscInitTypeDef RCC_OscInitStruct = {0};RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};//配置HSI振荡器RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;//选择振荡器类型为HSIRCC_OscInitStruct.HSIState = RCC_HSI_ON;//开启HSIRCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;//不分频
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_4MHz;//配置HSI输出时钟为4MHz
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_8MHz;//配置HSI输出时钟为8MHz
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_16MHz;//配置HSI输出时钟为16MHz
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_22p12MHz;//配置HSI输出时钟为22.12MHzRCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_24MHz; //配置HSI输出时钟为24MHzretData=HAL_RCC_OscConfig(&RCC_OscInitStruct);if(retData != HAL_OK)//初始化振荡器失败{}//初始化"系统时钟(SYSCLK),AHB时钟(HCLK)和APB时钟(PCLK)"RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;  //RCC系统时钟类型RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;//SYSCLK的源选择为HSIRCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;    //AHB时钟(HCLK)不分频,输出为APB时钟RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;     //APB时钟(PCLK)分频器为1分频,输出为PCLK时钟retData=HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);初始化RCC系统时钟(小于24MHz,则使用FLASH_LATENCY_0;大于24MHz且小于48MHz,则使用FLASH_LATENCY_1)if( retData!=HAL_OK)初始化RCC系统时钟失败{}
}

四、测试结果 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/77736.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

List与ArrayList

List与ArrayList

目录 一、List及其使用 1.1 List的概念 1.2 常见接口的介绍 1.3 List的使用 二、线性表和顺序表 2.1 线性表 2.2 顺序表 三、ArrayList介绍 四、ArrayList的使用 4.1 ArrayList构造 4.2 ArrayList的常用方法 4.3 ArrayList的遍历 4.4 ArrayList的扩容机制 五、ArrayList的具…
阅读更多...
字节一面：如何实现单行／多行文本溢出的省略样式？

字节一面：如何实现单行／多行文本溢出的省略样式？

前言 最近博主在字节面试中遇到这样一个面试题&#xff0c;这个问题也是前端面试的高频问题&#xff0c;作为一名前端开发工程师&#xff0c;css是我们的必备技能&#xff0c;文本溢出问题也是我们经常遇到的问题&#xff0c;我们不仅只是处理这种情况&#xff0c;还要考虑他的…
阅读更多...
024 - STM32学习笔记 - 液晶屏控制（一） - LTDC与DMA2D初始

024 - STM32学习笔记 - 液晶屏控制（一） - LTDC与DMA2D初始

024- STM32学习笔记 - LTDC控制液晶屏 在学习如何控制液晶屏之前&#xff0c;先了解一下显示屏的分类&#xff0c;按照目前市场上存在的各种屏幕材质&#xff0c;主要分为CRT阴极射线管显示屏、LCD液晶显示屏、LED显示屏、OLED显示屏&#xff0c;在F429的开发板上&#xff0c;…
阅读更多...
【多线程】线程池 详解

【多线程】线程池 详解

线程池 详解 1. 线程池是什么2. 标准库中的线程池3. 实现线程池4. 面试题 1. 线程池是什么 虽然线程的创建和销毁的开销比较小, 但还是有的, 如果频繁的创建和销毁线程, 开销还是比较大的.解决: 线程池或者协程, 本文主讲线程池. 线程池: 把线程提前创建好, 放到池子里, 后面…
阅读更多...
下载配置 maven并在 idea 上应用

下载配置 maven并在 idea 上应用

目录 一 maven 定义 二 Maven特点 三 Maven仓库 四 安装配置maven 步骤一:准备安装包,解压 步骤二:配置maven的环境变量 步骤三:测试maven的环境变量是否配置成功 步骤四:配置maven本地仓库 步骤五:阿里云、腾讯镜像配置 步骤六:全局配置idea的maven路径 步骤七:创建…
阅读更多...
命令行git联网失败，但是实际可以联网

命令行git联网失败，但是实际可以联网

最近下载代码的时候发现总是告诉我连不上github的网页&#xff0c;但是我自己通过浏览器又可以上网&#xff0c;找了半天发现这个方法可以。 记录下这个代理 打开git bash 执行以下命令&#xff1a; git config --global http.proxy http://127.0.0.1:7890 git config --glob…
阅读更多...
Python 图形化界面基础篇：添加复选框（ Checkbutton ）到 Tkinter 窗口

Python 图形化界面基础篇：添加复选框（ Checkbutton ）到 Tkinter 窗口

Python 图形化界面基础篇&#xff1a;添加复选框&#xff08; Checkbutton &#xff09;到 Tkinter 窗口 引言什么是 Tkinter 复选框&#xff08; Checkbutton &#xff09;&#xff1f;步骤1&#xff1a;导入 Tkinter 模块步骤2&#xff1a;创建 Tkinter 窗口步骤3&#xff1a…
阅读更多...
【C++】封装unordered_map和unordered_set（用哈希桶实现）

【C++】封装unordered_map和unordered_set（用哈希桶实现）

前言&#xff1a; 前面我们学习了unordered_map和unordered_set容器&#xff0c;比较了他们和map、set的查找效率&#xff0c;我们发现他们的效率比map、set高&#xff0c;进而我们研究他们的底层是由哈希实现。哈希是一种直接映射的方式&#xff0c;所以查找的效率很快…
阅读更多...
LeetCode——动态规划篇（一）

LeetCode——动态规划篇（一）

刷题顺序及思路来源于代码随想录&#xff0c;网站地址&#xff1a;https://programmercarl.com 目录 509. 斐波那契数 - 力扣&#xff08;LeetCode&#xff09; 70. 爬楼梯 - 力扣&#xff08;LeetCode&#xff09; 746. 使用最小花费爬楼梯 - 力扣&#xff08;LeetCode&a…
阅读更多...
瞄准办公场景，未来智能靠“AI+耳机”后来居上？

瞄准办公场景，未来智能靠“AI+耳机”后来居上？

如何在广阔红海中开拓出蓝海&#xff1f;未来智能或可作为参考案例。 作为TWS耳机玩家&#xff0c;未来智能成立于2021年&#xff0c;日前完成了由天际资本领投的数千万元Pre-A轮融资&#xff0c;这也是该公司成立以来完成的第二轮融资。 从成立时间来看&#xff0c;在广阔的…
阅读更多...
Linux---应用层获取usb设备描述信息通过endpoint地址数据通讯

Linux---应用层获取usb设备描述信息通过endpoint地址数据通讯

文章目录 &#x1f308;应用层获取USB设备信息总体思路&#x1f308;应用层代码实例&#x1f308;实例测试&#x1f308;应用层通过endpoint进行数据读写 &#x1f308;应用层获取USB设备信息总体思路 应用层可以打开USB设备的节点&#xff0c;读取包括USB设备的配置&#xff…
阅读更多...
deepspeed训练报错torch.distributed.elastic.multiprocessing.errors.ChildFailedError

deepspeed训练报错torch.distributed.elastic.multiprocessing.errors.ChildFailedError

测试场景&#xff1a;使用deepspeed框架训练gpt模型 问题&#xff1a; 报错torch.distributed.elastic.multiprocessing.errors.ChildFailedError 具体见截图&#xff1a;
阅读更多...
UMA 2 - Unity Multipurpose Avatar☀️六.Advanced Occlusion高级遮挡功能解决皮肤服饰穿模

UMA 2 - Unity Multipurpose Avatar☀️六.Advanced Occlusion高级遮挡功能解决皮肤服饰穿模

文章目录 🟥 本节功能效果展示🟧 基础项目配置🟨 本节项目配置🟩 配置MeshHideAsset1️⃣ 创建MeshHideAsset2️⃣ 配置SlotDataAsset3️⃣ 配置遮挡信息🟦 将 MeshHideAsset 配置到 Recipe🟥 本节功能效果展示 未遮挡前的穿模问题: 遮挡后效果:
阅读更多...
厂商征集 | 2023年中国RPA市场洞察研究报告正式启动

厂商征集 | 2023年中国RPA市场洞察研究报告正式启动

RPA中国基于在科技行业的资源积累&#xff0c;以及对各领域「技术领导者」、「技术应用者」、「产品服务商」的深度调研&#xff0c;2023年&#xff0c;我们重点推出MI报告 ( Market Insight )、CI Vendor报告&#xff08;Comprehensive Influence Vendor&#xff09;两个系列。…
阅读更多...
【Jmeter】什么是BeanShell？

【Jmeter】什么是BeanShell？

一、什么是BeanShell&#xff1f; BeanShell是用Java写成的,一个小型的、免费的、可以下载的、嵌入式的Java源代码解释器&#xff0c;JMeter性能测试工具也充分接纳了BeanShell解释器&#xff0c;封装成了可配置的BeanShell前置和后置处理器&#xff0c;分别是 BeanShell Pre…
阅读更多...
NoSQL之Redis配置与优化（一）

NoSQL之Redis配置与优化（一）

关系数据库与非关系型数据库 &#xff1a; ●关系型数据库&#xff1a; 关系型数据库是一个结构化的数据库&#xff0c;创建在关系模型&#xff08;二维表格模型&#xff09;基础上&#xff0c;一般面向于记录。 SQL 语句&#xff08;标准数据查询语言&#xff09;就是一种基于…
阅读更多...
FP7122 具有平均模式恒定电流控制的LED驱动器芯片

FP7122 具有平均模式恒定电流控制的LED驱动器芯片

FP7122 具有平均模式恒定电流控制的LED驱动器芯片 一般说明 FP7122是在恒定关闭时间模式下工作的平均电流模式控制LED驱动器IC。FP7122不产生峰值到平均的误差&#xff0c;因此大大提高了LED电流的精度、线路和负载调节&#xff0c;而不需要任何回路补偿或高侧电流传感。输出的…
阅读更多...
VB：二分法查找

VB：二分法查找

VB&#xff1a;二分法查找 二分查找算法 Private Sub Command1_Click()Dim i%, m%, n%Dim x(1 To 10) As SingleFor i 1 To 10x(i) Val(InputBox("请输入"))Next iCall bubbleSort(x)For i LBound(x) To UBound(x) LBound(x)和UBound(x)是用于获取数组x的下界和上…
阅读更多...
运营技巧｜如何在不同的平台上高效批量管理账户？

运营技巧｜如何在不同的平台上高效批量管理账户？

在当今全球化时代&#xff0c;中国出海企业和B2B外贸企业越来越重视海外社媒营销&#xff0c;这已成为企业抢占市场份额的关键。并且&#xff0c;为了获取到更多流量&#xff0c;跨境人们还会开通Facebook、Twitter、Google、TikTok、Instagram等平台账号&#xff0c;搭建自己的…
阅读更多...
教你制作作业查询系统

教你制作作业查询系统

嗨&#xff0c;各位老师们&#xff0c;今天我要给你们介绍一个超级方便的工具——易查分&#xff01;你知道吗&#xff0c;利用易查分&#xff0c;我们可以轻松制作一个便捷高效的作业查询系统哦&#xff01; 是不是想有个自己的分班or成绩查询页面&#xff1f;博主给老师们争取…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023