STM32学习心得二十一：实时时钟RTC和备份寄存器BKP特征、原理及相关实验代码解读

记录一下，方便以后翻阅~
主要内容
1） RTC特征与原理；
2） BKP备份寄存器特征与原理；
3） RTC常用寄存器+库函数介绍；
4） 相关实验代码解读。
实验内容：
因为没有买LCD屏，所以计划通过串口实时更新时间。系统运行后，串口调试助手实时显示当前时间，可通过USMART工具，修改当前时间和闹钟时间，闹钟触发后，蜂鸣器会叫1s时长。板子正常运行时，LED0和LED1交替闪烁。
官方资料：《STM32中文参考手册V10》第16章——实时时钟(RTC)和第5章——备份寄存器
1. RTC实时时钟特征与原理
1.1 RTC (Real Time Clock)称实时时钟。RTC是独立的定时器，RTC模块拥有一个连续计数的计数器，在相应的软件配置下，可以提供时钟日历的功能，修改计数器的值可以重新设置当前时间和日期；
1.2 RTC模块和时钟配置系统(RCC_BDCR寄存器)是在后备区域，即在系统复位或从待机模式唤醒后RTC的设置和时间维持不变。但是在系统复位后，会自动禁止访问后备寄存器和RTC，以防止对后备区域(BKP)的意外写操作。所以在要设置时间之前， 先要取消备份区域（BKP）写保护；
1.3 RTC特征如下图所示：

1.4 RTC工作原理框图

1.4.1 RTC预分频器，RTCCLK除以RTC_PRL的重装载值后，值为分频后的TR_CLK的值，一般情况下TR_CLK设1Hz；
1.4.2 RTC预分频器，RTC_DIV装载从RTC_PRL的重装载值，每个RTCCLK周期值减1，至0后会溢出；
1.4.3 待机时维持供电，RTC_CNT，每个TR_CLK周期加1，直至溢出，触发溢出中断；当RTC_ALR所设值等于RTC_CNT实时值时，触发闹钟中断；每个TR_CLK周期产生一次中断。
由原理框图可知RTC的组成：
APB1接口：用来和APB1总线相连。通过APB1接口可以访问RTC的相关寄存器（预分频值，计数器值，闹钟值）。
RTC核心：由一组可编程计数器组成，分两个主要模块：
1）第一个是RTC预分频模块，它可以编程产生最长1秒的RTC时间基TR_CLK。如果设置了秒中断允许位，可以产生秒中断；
2）第二个是32位的可编程计数器，可被初始化为当前时间。系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比，当匹配时候如果设置了闹钟中断允许位，可以产生闹钟中断。
备注：RTC内核完全独立于APB1接口，软件通过APB1接口对RTC相关寄存器访问。但是相关寄存器只在RTC APB1时钟进行重新同步的RTC时钟的上升沿被更新。所以软件必须先等待寄存器同步标志位（RTC_CRL的RSF位）被硬件置1才读。
1.5 RTC时钟源（有三个时钟源可选，一般采用外部时钟）

2. BKP备份寄存器
2.1 备份寄存器是42个16位的寄存器，可用来存储84个字节数据；
2.2 它们处在备份区域，当VDD电源切断，仍然由VBAT（板子上的纽扣电池）维持供电；
2.3 当系统在待机模式下被唤醒，或者系统复位或者电源复位，它们也不会复位；
2.4 执行以下操作将使能对后备寄存器和RTC访问：
2.4.1 置寄存器RCC_APB1ENR的PWREN和BKPEN位，使能电源和后备时钟；
2.4.2 设置寄存器PWR_CR的DBP位，使能对RTC和后备寄存器的访问。
2.5 BKP备份寄存器常用来保存一些系统配置信息和相关标志位。

3. RTC常用寄存器
3.1 RTC控制寄存器 (RTC_CRH（高位）， RTC_CRL（低位）)；

3.1.1 修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步；
3.1.2 修改CNT,ALR,PRL的时候，必须先配置CNF位进入配置模式，修改完之后，设置CNF位为0退出配置模式；
3.1.3 同时在对RTC相关寄存器写操作之前，必须判断上一次写操作已经结束，也就是判断RTOFF位是否置位。
3.2 RTC预分频装载寄存器 (RTC_PRLH， RTC_PRLL)；

3.3 RTC预分频余数寄存器 (RTC_DIVH， RTC_DIVL)；

3.4 RTC计数器寄存器 (RTC_CNTH， RTC_CNTL)；

3.5 RTC闹钟寄存器 (RTC_ALRH， RTC_ALRL)；

3.6 配置RTC寄存器

3.7 读RTC寄存器

4. RTC常用库函数
4.1 STM32提供的官方库函数文件名为：
stm32f10x_rtc.c 和stm32f10x_rtc.h;
4.2 具体库函数为：

void RTC_ITConfig(uint16_t RTC_IT, FunctionalStateNewState);
void RTC_EnterConfigMode(void);
void RTC_ExitConfigMode(void);
uint32_t  RTC_GetCounter(void);
void RTC_SetCounter(uint32_t CounterValue);
void RTC_SetPrescaler(uint32_t PrescalerValue);
void RTC_SetAlarm(uint32_t AlarmValue);
uint32_t  RTC_GetDivider(void);
void RTC_WaitForLastTask(void);
void RTC_WaitForSynchro(void);
FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
void RTC_ClearFlag(uint16_t RTC_FLAG);
ITStatus RTC_GetITStatus(uint16_t RTC_IT);
void RTC_ClearITPendingBit(uint16_t RTC_IT);

4.3 RTC时钟源和时钟操作函数：

void RCC_RTCCLKConfig(uint32_t  CLKSource);      //时钟源选择
void RCC_RTCCLKCmd(FunctionalState NewState);    //时钟使能

4.4 RTC配置函数（预分频，计数值）：

void RTC_SetPrescaler(uint32_t PrescalerValue);  //预分频配置：PRLH/PRLL
void RTC_SetCounter(uint32_t CounterValue);      //设置计数器值：CNTH/CNTL
void RTC_SetAlarm(uint32_t AlarmValue);          //闹钟设置：ALRH/ALRL

4.5 RTC中断设置函数：

void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState);    //CRH

4.6 RTC允许配置和退出配置函数：

void RTC_EnterConfigMode(void);                                  //允许RTC配置  : CRL位 CNF
void RTC_ExitConfigMode(void);                                   //退出配置模式 : CRL位 CNF

4.7 同步函数：

void RTC_WaitForLastTask(void);                                 //等待上次操作完成：CRL位RTOFF
void RTC_WaitForSynchro(void);                                  //等待时钟同步：CRL位RSF

4.8 相关状态位获取清除函数：

FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
void RTC_ClearFlag(uint16_t RTC_FLAG);      
ITStatus RTC_GetITStatus(uint16_t RTC_IT);
void RTC_ClearITPendingBit(uint16_t RTC_IT);

1.9 其他相关函数（BKP等）

PWR_BackupAccessCmd();                                         //BKP后备区域访问使能
RCC_APB1PeriphClockCmd();                                      //使能PWR和BKP时钟        
RCC_LSEConfig();                                               //开启LSE，RTC选择LSE作为时钟源        
PWR_BackupAccessCmd();                                         //BKP后备区域访问使能        
uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR);              //读BKP寄存器      
void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data);  //写BKP

5. RTC一般配置步骤
5.1 使能PWR和BKP时钟：

RCC_APB1PeriphClockCmd();

5.2 使能后备寄存器访问：

PWR_BackupAccessCmd();

5.3
配置RTC时钟源，使能RTC时钟：

RCC_RTCCLKConfig();
RCC_RTCCLKCmd();

如果使用LSE，要打开LSE：RCC_LSEConfig(RCC_LSE_ON)；
5.4 设置RTC预分频系数：

RTC_SetPrescaler();

5.5 设置时间：

RTC_SetCounter();

5.6 开启相关中断（如果需要）：

RTC_ITConfig();

5.7 编写中断服务函数：

RTC_IRQHandler();

5.8 部分操作要等待写操作完成和同步。

RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
RTC_WaitForSynchro();     //等待RTC寄存器同步 

6. 相关实验代码
6.1 rtc.h头文件代码

#ifndef __RTC_H
#define __RTC_H     
#include "stm32f10x.h"
//定义一个时间结构体//
typedef struct 
{
 vu8 hour;     //时
 vu8 min;      //分
 vu8 sec;      //秒
 vu16 w_year;  //年
 vu8  w_month; //月
 vu8  w_date;  //日
 vu8  week;    //周 
}_calendar_obj;      
extern _calendar_obj calendar;                //日历结构体，已在rtc.c中申明了//
extern u8 const mon_table[12];                //月份日期数据表，常数
void Disp_Time(u8 x,u8 y,u8 size);            //在制定位置开始显示时间
void Disp_Week(u8 x,u8 y,u8 size,u8 lang);    //在指定位置显示星期
u8 RTC_Init(void);                            //初始化RTC,返回0,失败;1,成功;
u8 Is_Leap_Year(u16 year);                    //平年,闰年判断，返回1是，0不是
u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);  //闹钟设定
u8 RTC_Get(void);                             //获取时间   
u8 RTC_Get_Week(u16 year,u8 month,u8 day);    //获取日期，返回0成功，其他失败
u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);        //设置时间    
#endif

6.2 rtc.c文件代码

#include "beep.h"
#include "rtc.h"  
#include "sys.h"
#include "delay.h"
#include "usart.h"
//时钟结构体//
_calendar_obj calendar;                                      
static void RTC_NVIC_Config(void)
{ 
 NVIC_InitTypeDef NVIC_InitStructure;
 NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;             //RTC全局中断
 NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级1位,从优先级3位
 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         //抢占优先级0位,从优先级4位
 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //使能该通道中断
 NVIC_Init(&NVIC_InitStructure);  
}
//实时时钟配置
//初始化RTC时钟,同时检测时钟是否工作正常
//BKP->DR1用于保存是否第一次配置的设置
//返回0:正常; 其他:错误代码
u8 RTC_Init(void)
{
 //检查是不是第一次配置时钟//
 u8 temp=0;
 //*****第一步*****//
 //电源控制PWR，当主电源VDD掉电后，通过VBAT脚为实时时钟(RTC)和备份寄存器(BKP)提供电源//
 //使能PWR和BKP外设时钟//  
 RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE); 
 //*****第二步*****// 
 //使能后备寄存器访问，位带操作，实际对电源控制寄存器PWR_CR的第八位DBP写1，允许写入RTC和BKP// 
 PWR_BackupAccessCmd(ENABLE); 
 //读取BKP_DR1寄存器0~15位的值，判断是否与0x5050一致//
 if (BKP_ReadBackupRegister(BKP_DR1) != 0x5050)  
  { 
   //如果不一致，说明第一次配置，则进行如下操作//   
   BKP_DeInit();                           //复位备份区域//  
   RCC_LSEConfig(RCC_LSE_ON);              //设置外部低速晶振(LSE),使用外设低速晶振//
   //备份域控制寄存器RCC_BDCR，位1，LSERDY为0时未就绪，为1时就绪//
   while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)
    {
     temp++;
     delay_ms(10);
    }
   if(temp>=250)return 1;                   //初始化时钟失败,晶振有问题，结束u8 RTC_Init(void)函数// 
   //若temp＜250，则继续// 
   //*****第三步*****//   
   RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);  //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟//    
   RCC_RTCCLKCmd(ENABLE);                   //使能RTC时钟//  
   //*****配置RTC寄存器开始*****//   
   //*****第六步*****//
   //RTC控制寄存器低位(RTC_CRL)，位5，RTOFF为0时仍在写操作，为1时写操作完成，该函数循环执行，直到RTOFF为1// 
   RTC_WaitForLastTask();    
   //RTC控制寄存器低位(RTC_CRL)，位3，RSF为0时寄存器未同步，为1时寄存器同步，该函数循环执行，直到 RSF 为1//
   //因为修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步//  
   RTC_WaitForSynchro();                     
   RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);     //对控制寄存器高位(RTC_CRH)操作，使能RTC秒中断//
   RTC_WaitForLastTask();                             //等待最近一次对RTC寄存器的写操作完成//   
   //*****第四步和第五步*****//
   //RTC控制寄存器低位(RTC_CRL)，位4，CNF置1，进入配置模式//
   RTC_EnterConfigMode();                    
   RTC_SetPrescaler(32767);                           //设置RTC预分频的值//
   RTC_WaitForLastTask();                             //等待最近一次对RTC寄存器的写操作完成//
   RTC_Set(2015,1,14,17,42,55);                       //设置时间，纯c语言代码// 
   //RTC控制寄存器低位(RTC_CRL)，位4，CNF置0，退出配置模式//
   RTC_ExitConfigMode();                      
   //写入BKP_DR1寄存器0~15位的值//
   BKP_WriteBackupRegister(BKP_DR1, 0X5050);          //向指定的后备寄存器中写入用户程序数据//
  }
 else                                                 //如果，不是第一次配置，系统继续计时//
  {
    RTC_WaitForSynchro();                             //等待寄存器同步// 
    RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);         
    RTC_WaitForLastTask();                            //等待最近一次对RTC寄存器的写操作完成//
  }
 RTC_NVIC_Config();                                   //RCT中断分组设置//               
 RTC_Get();                                           //更新时间//
 return 0;                                            //ok//
}           
//*****第七步，编写中断服务函数*****//
//秒中断发生，更新时间，闹钟中断发生，更新时间并向串口发送时间//
void RTC_IRQHandler(void)
{   
 if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)              //判断闹钟中断是否发生//
 {
  //RTC控制寄存器低位(RTC_CRL)，位1，ALRF置0，清闹钟中断// 
  RTC_ClearITPendingBit(RTC_IT_ALR);           
  RTC_Get();                                          //更新时间//  
  printf("闹钟时间:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
  BEEP=1;
  delay_ms(1000);
  BEEP=0;      
  }   
 if (RTC_GetITStatus(RTC_IT_SEC) != RESET)            //判断秒钟中断是否发生//
 {       
 RTC_Get(); 
 printf("闹钟时间:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec); 
 }   
            
 RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);         //清闹钟中断和溢出标志//
 RTC_WaitForLastTask();                               //等待最近一次对RTC寄存器的写操作完成//    
}
//判断是否是闰年函数，能被4整除，但不能被100整除的年是闰年，能被400整除的年是闰年//
//月份        1  2  3  4  5  6  7  8  9  10 11 12
//闰年        31 29 31 30 31 30 31 31 30 31 30 31
//非闰年/平年 31 28 31 30 31 30 31 31 30 31 30 31
//输入:年份
//输出:该年份是不是闰年.1,是.0,不是
u8 Is_Leap_Year(u16 year)
{     
 if(year%4==0)                              //判断是否能被4整除，能则继续；不能则不是闰年，且返回0//
 { 
  if(year%100==0)                           //判断是否能被100整除,能则继续；不能则是闰年，且返回1// 
  { 
   if(year%400==0)return 1;                 //判断是否能被400整除，能则是闰年，且返回1；不能则不是闰年，且返回0//    
   else return 0;   
  }else return 1;   
 }else return 0; 
}        
//设置时钟，把输入的时钟转换为秒钟，以1970年1月1日为基准，1970~2099年为合法年份//
//并将值传至RTC计数器寄存器高位(RTC_CNTH)和RTC计数器寄存器低位(RTC_CNTL)中// 
//返回值:0,成功;其他:错误代码//           
//平年的月份日期表，闰年的话，就把28改29//
const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
{
 u16 t;
 u32 seccount=0;
 if(syear<1970||syear>2099)return 1;               //如果年份不在1970~2099年之内，则报错，函数停止//
 for(t=1970;t<syear;t++)                           //把所有年份的秒钟相加//
 {
  if(Is_Leap_Year(t))seccount+=31622400;           //闰年的秒钟数//
  else seccount+=31536000;                         //平年的秒钟数，少一天//
 }
 smon-=1;
 for(t=0;t<smon;t++)                               //把前面月份的秒钟数相加//
 {
  seccount+=(u32)mon_table[t]*86400;               //月份秒钟数相加//
  if(Is_Leap_Year(syear)&&t==1)seccount+=86400;    //闰年2月份增加一天的秒钟数 //   
 }
 seccount+=(u32)(sday-1)*86400;                    //把前面日期的秒钟数相加// 
 seccount+=(u32)hour*3600;                         //小时秒钟数//
 seccount+=(u32)min*60;                            //分钟秒钟数//
 seccount+=sec;                                    //最后的秒钟加上去//
 //以上，已经把某年某月某日某时某分某秒的时间，用秒计数起来//
 RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE); //使能PWR和BKP外设时钟//  
 PWR_BackupAccessCmd(ENABLE);                                             //使能RTC和BKP访问//
 RTC_SetCounter(seccount);                                                //设置RTC计数器的值//
 RTC_WaitForLastTask();    
 return 0;     
}
//初始化闹钟，以1970年1月1日为基准，1970~2099年为合法年份，syear,smon,sday,hour,min,sec：年月日时分秒//   
//返回值:0,成功;其他:错误代码.//
u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
{
 u16 t;
 u32 seccount=0;
 if(syear<1970||syear>2099)return 1;    
 for(t=1970;t<syear;t++)                        //把所有年份的秒钟相加//
 {
  if(Is_Leap_Year(t))seccount+=31622400;        //闰年的秒钟数//
  else seccount+=31536000;                      //平年的秒钟数//
 }
 smon-=1;
 for(t=0;t<smon;t++)                            //把前面月份的秒钟数相加//
 {
  seccount+=(u32)mon_table[t]*86400;            //月份秒钟数相加//
  if(Is_Leap_Year(syear)&&t==1)seccount+=86400; //闰年2月份增加一天的秒钟数//    
 }
 seccount+=(u32)(sday-1)*86400;                 //把前面日期的秒钟数相加//
 seccount+=(u32)hour*3600;                      //小时秒钟数//
    seccount+=(u32)min*60;                      //分钟秒钟数//
 seccount+=sec;                                 //最后的秒钟加上去//       
 //设置时钟//
 RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);  //使能PWR和BKP外设时钟//   
 PWR_BackupAccessCmd(ENABLE);                                              //使能RTC和BKP访问//  
 RTC_SetAlarm(seccount);                                                   //设置RTC闹钟寄存器值//
 RTC_WaitForLastTask();   
 return 0;     
}
//得到当前的时间，将秒转换成年月日时分秒//
//返回值:0,成功;其他:错误代码.//
u8 RTC_Get(void)
{
 static u16 daycnt=0;
 u32 timecount=0; 
 u32 temp=0;
 u16 temp1=0;   
  timecount=RTC_GetCounter();   //获取16位RTC计数器寄存器高位RTC_CNTH和低位RTC_CNTL的值，返回32位数据//
  temp=timecount/86400;         //得到天数//
 if(daycnt!=temp)               //超过一天了
 {   
  daycnt=temp;
  temp1=1970;                   //从1970年开始//
  while(temp>=365)              //当temp≥365天时//
  {     
   if(Is_Leap_Year(temp1))      //闰年判断，闰年366天，平年365天//
   {
    if(temp>=366)
     temp-=366;                 //闰年，temp减366天//
    else break;                 //当年是闰年，且是365天时，跳出循环//
   }
   else  temp-=365;             //平年，temp减365天// 
   temp1++;                     //平年，temp1加1年//
  }   
  calendar.w_year=temp1;        //得到年份temp1//
  temp1=0;                      //temp1至0，开始计算月份//
  while(temp>=28)               //当28≤temp＜365天时//
  {
   //temp1从0至11分别对应1月到12月//
   if(Is_Leap_Year(calendar.w_year)&&temp1==1)         //当是闰年，且为2月份时，执行下面语句//
   {
    if(temp>=29)temp-=29;                              
    else break; 
   }
   else                                                //平年，执行else//
   {
    if(temp>=mon_table[temp1])                         
     temp-=mon_table[temp1];                          
    else break;
   }
   temp1++;  
  }
  calendar.w_month=temp1+1;                            //得到月份//
  calendar.w_date=temp+1;                              //得到日期// 
 }
 temp=timecount%86400;                                 //得到秒钟数//      
 calendar.hour=temp/3600;                              //小时//
 calendar.min=(temp%3600)/60;                          //分钟// 
 calendar.sec=(temp%3600)%60;                          //秒钟//
 calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date); //获取星期//   
 return 0;
}  
//获得现在是星期几
//功能描述:输入公历日期得到星期(只允许1901-2099年)
//输入参数：公历年月日 
//返回值：星期号  
u8 const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5};        //月修正数据表?//
u8 RTC_Get_Week(u16 year,u8 month,u8 day)
{ 
 u16 temp2;
 u8 yearH,yearL;
 yearH=year/100; yearL=year%100; 
 //如果为21世纪,年份数加100//  
 if (yearH>19)
  yearL+=100;
 //所过闰年数只算1900年之后的//  
 temp2=yearL+yearL/4;
 temp2=temp2%7; 
 temp2=temp2+day+table_week[month-1];
 if (yearL%4==0&&month<3)temp2--;
 return(temp2%7);
}  

6.3 main.c文件代码

#include "led.h"
#include "beep.h"
#include "rtc.h" 
#include "delay.h"
#include "sys.h"
#include "usart.h" 
#include "usmart.h" 
//主函数//
 int main(void)
 {  
 u8 t=0; 
 delay_init();                                      //延时函数初始化//   
 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置中断优先级分组为组2：2位抢占优先级，2位响应优先级//
 uart_init(115200);                                 //串口初始化为115200//
 LED_Init();                                        //LED端口初始化//
 BEEP_Init();
 BEEP=1;
 delay_ms(1000);
 BEEP=0;
 LED0=0;                                            //LED0亮//
 usmart_dev.init(SystemCoreClock/1000000);          //初始化USMART// 
 RTC_Init();                                        //RTC初始化//    
 while(1)
 {            
  if(t!=calendar.sec)
  {
   t=calendar.sec;                                  //如果calendar.sec不更新，则t不更新//
   LED0=!LED0;                                      //每次calendar.sec更新，LED0和LED1交替闪烁//
   LED1=!LED1;
  } 
  delay_ms(10);          
 }  
 }

最后调试效果如下图所示

9. 旧知识点
1）复习如何新建工程模板，可参考STM32学习心得二：新建工程模板；
2）复习基于库函数的初始化函数的一般格式，可参考STM32学习心得三：GPIO实验-基于库函数；
3）复习寄存器地址，可参考STM32学习心得四：GPIO实验-基于寄存器；
4）复习位操作，可参考STM32学习心得五：GPIO实验-基于位操作；
5）复习寄存器地址名称映射，可参考STM32学习心得六：相关C语言学习及寄存器地址名称映射解读；
6）复习时钟系统框图，可参考STM32学习心得七：STM32时钟系统框图解读及相关函数；
7）复习延迟函数，可参考STM32学习心得九：Systick滴答定时器和延时函数解读；
8）复习ST-LINK仿真器的参数配置，可参考STM32学习心得十：在Keil MDK软件中配置ST-LINK仿真器；
9）复习ST-LINK调试方法，可参考STM32学习心得十一：ST-LINK调试原理+软硬件仿真调试方法；
10）复习如何对GPIO进行复用，可参考STM32学习心得十二：端口复用和重映射；
11）复习中断相关知识，可参考STM32学习心得十三：NVIC中断优先级管理；
12）复习串口通信相关知识，可参考STM32学习心得十四：串口通信相关知识及配置方法；
13）复习通用定时器基本原理，可参考STM32学习心得十八：通用定时器基本原理及相关实验代码解读；
14）复习USMART调试工具，可参考STM32学习心得二十：USMART调试组件实验。