stm32 BKP寄存器操作[操作寄存器+库函数]

BKP是“BACKUP”的缩写，stm32f103RCTE的内部配备了10个16位宽度的BKP寄存器。在主电源切断或系统产生复位时间时，BKP寄存器仍然可以在备用电源的支持下保持其内容。 

BKP在实际应用中可以存入重要数据，防止被恶意查看，或用于断电回复等。

 

本例实现对BKP寄存器的读写操作，和入侵检测和处理。主程序中写入寄存器后，依次打印出10个BKP寄存器数据，然后触发GPIOC13的入侵中断（输入低电平），在中断中打印出入侵事件发生后的寄存器内容（复位为0 ）。

 

直接操作寄存器

用到的寄存器描述如下：

 

备份数据寄存器x(BKP_DRx) (x = 1 … 10)：低16位[15:0]有效，用来写入或读出备份数据。

 

备份控制寄存器(BKP_CR)：

低两位有效。

TPAL[1]：侵入检测TAMPER引脚有效电平(TAMPER pin active level)

•          0：侵入检测TAMPER引脚上的高电平会清除所有数据备份寄存器(如果TPE位为1)
•          1：侵入检测TAMPER引脚上的低电平会清除所有数据备份寄存器(如果TPE位为1)

TPE[0]：启动侵入检测TAMPER引脚(TAMPER pin enable)

• 0：侵入检测TAMPER引脚作为通用IO口使用
• 1：开启侵入检测引脚作为侵入检测使用

备份控制/状态寄存器(BKP_CSR):

 

TIF[9]：侵入中断标志(Tamper interrupt flag)      0：无侵入中断     1：产生侵入中断

当检测到有侵入事件且TPIE位为1时，此位由硬件置1。

通过向CTI位写1来清除此标志位(同时也清除了中断)。如果TPIE位被清除，则此位也会被清除。 

 

TEF[8]：侵入事件标志(Tamper event flag)         0：无侵入事件       1：检测到侵入事件 

当检测到侵入事件时此位由硬件置1。通过向CTE位写1可清除此标志位 

 

TPIE[2]：允许侵入TAMPER引脚中断(TAMPER pin interrupt enable)

0：禁止侵入检测中断 1：允许侵入检测中断(BKP_CR寄存器的TPE位也必须被置1)

注1：侵入中断无法将系统内核从低功耗模式唤醒。 注2：仅当系统复位或由待机模式唤醒后才复位该位。

 

CTI[1]：清除侵入检测中断(Clear tamper interrupt)  

0：无效 1：清除侵入检测中断和TIF侵入检测中断标志

 

CTE[0]：清除侵入检测事件(Clear tamper event)

 0：无效 1：清除TEF侵入检测事件标志(并复位侵入检测器)。

 

要写入BKP寄存器数据必须在 PWR->CR中取消备份区写保护，才可以写入BKP数据。stm32开启入侵检测也不需要设置GPIOC的时钟和输入输出模式。

 

代码如下： （system.h 和  stm32f10x_it.h  等相关代码参照  stm32 直接操作寄存器开发环境配置 ）

User/main.c

01 #include
02 #include "system.h"
03 #include "usart.h"
04 #include "bkp.h"
05
06 #define LED1 PAout(4)
07 #define LED2 PAout(5)
08
09 void Gpio_Init(void);
10
11 int main(void)
12 {
13     u16 data,i=10;
14
15     Rcc_Init(9);                          //系统时钟设置
16
17     Usart1_Init(72,9600);
18
19     Bkp_Init();
20
21     Tamper_Init();
22
23     Nvic_Init(0,0,TAMPER_IRQChannel,0);   //设置中断
24
25     Gpio_Init();
26
27     while(i){
28
29         Write_Bkp(i,i);
30
31         data = Read_Bkp(i);
32
33         printf("\n DR%u = 0x%04X\n",i,data);
34
35         delay(30000);   //延时30ms
36
37         i--;
38
39     }
40
41     while(1);
42 }
43
44
45 void Gpio_Init(void)
46 {
47     RCC->APB2ENR|=1<<2;    //使能PORTA时钟
48
49     GPIOA->CRL&=0x0000FFFF; // PA0~3设置为浮空输入，PA4~7设置为推挽输出
50     GPIOA->CRL|=0x33334444;
51
52
53     //USART1 串口I/O设置
54
55     GPIOA -> CRH&=0xFFFFF00F;   //设置USART1 的Tx(PA.9)为第二功能推挽，50MHz；Rx(PA.10)为浮空输入
56     GPIOA -> CRH|=0x000008B0;
57 }

User/stm32f103x_it.c

01 #include "stm32f10x_it.h"
02 #include "system.h"
03 #include "stdio.h"
04
05 #define LED1 PAout(4)
06 #define LED2 PAout(5)
07 #define LED3 PAout(6)
08 #define LED4 PAout(7)
09
10 extern u16 Read_Bkp(u8 reg);
11
12 void TAMPER_IRQHandler(void)
13 {
14     u16 i=10,data;
15
16     LED4 =1 ;
17
18     printf("\r\n A Tamper is coming .\r\n");
19
20     while(i){
21
22         data = Read_Bkp(i);
23
24         printf("\n DR%u = 0x%04X\n",i,data);
25
26         delay(30000);   //延时30ms
27
28         i--;
29
30     }
31
32     BKP->CSR |= 3<<0;  //清除事件中断标志位
33
34 }

Library/src/bkp.c

001 #include
002 #include "bkp.h"
003
004 void Bkp_Init(void)
005 {
006     RCC->APB1RSTR |= 1<<27;        //复位BKP寄存器
007     RCC->APB1RSTR &= ~(1<<27);
008
009     RCC->APB1ENR|=1<<28;     //使能电源时钟
010     RCC->APB1ENR|=1<<27;     //使能BKP时钟
011 }
012
013
014 /**
015  *
016  *后备寄存器写入操作
017  *reg:寄存器编号
018  *data:要写入的数值
019  *
020  **/
021 void Write_Bkp(u8 reg,u16 data)
022 {
023
024     PWR->CR|=1<<8;           //取消备份区写保护
025
026     switch(reg)
027     {
028         case 1:
029             BKP->DR1=data;
030             break;
031         case 2:
032             BKP->DR2=data;
033             break;
034         case 3:
035             BKP->DR3=data;
036             break;
037         case 4:
038             BKP->DR4=data;
039             break;
040         case 5:
041             BKP->DR5=data;
042             break;
043         case 6:
044             BKP->DR6=data;
045             break;
046         case 7:
047             BKP->DR7=data;
048             break;
049         case 8:
050             BKP->DR8=data;
051             break;
052         case 9:
053             BKP->DR9=data;
054             break;
055         case 10:
056             BKP->DR10=data;
057             break;
058     }
059 }
060
061
062 u16 Read_Bkp(u8 reg)
063 {
064     u16 data;
065
066     switch(reg)
067     {
068         case 1:
069             data = BKP->DR1;
070             break;
071         case 2:
072             data = BKP->DR2;
073             break;
074         case 3:
075             data = BKP->DR3;
076             break;
077         case 4:
078             data = BKP->DR4;
079             break;
080         case 5:
081             data = BKP->DR5;
082             break;
083         case 6:
084             data = BKP->DR6;
085             break;
086         case 7:
087             data = BKP->DR7;
088             break;
089         case 8:
090             data = BKP->DR8;
091             break;
092         case 9:
093             data = BKP->DR9;
094             break;
095         case 10:
096             data = BKP->DR10;
097             break;
098     }
099
100     return data;
101 }
102
103 //开启入侵检测,检测引脚为GPIOC13 但是不用打开其时钟和设置引脚模式
104 void Tamper_Init()
105 {
106
107     BKP->CSR |= 3<<0;          //清除事件中断标志位
108
109     BKP->CR  |= 1<<1;          //设定为入侵电平为低电平
110     BKP->CSR |= 1<<2;          //允许入侵中断
111
112     BKP->CR  |= 1<<0;          //开启入侵检测
113
114
115 }

Library/inc/bkp.h

1 #include
2
3 void Bkp_Init(void);
4
5 void Write_Bkp(u8 reg,u16 data);
6
7 u16 Read_Bkp(u8 reg);
8
9 void Tamper_Init(void);

 

库函数操作

 

main.c

001 #include "stm32f10x.h"
002 #include "stdio.h"
003
004
005 #define  PRINTF_ON  1
006 #define  CHECK_CODE  0xAE86
007
008
009 void RCC_Configuration(void);
010 void GPIO_Configuration(void);
011 void NVIC_Configuration(void);
012 void USART_Configuration(void);
013 void BKP_Configuration(void);
014
015 void PrintBKP(void);
016 void WriteBKP(u16 Data,u8 DRNumber);
017 u8   CheckBKP(void);
018
019 int main(void)
020 {
021     RCC_Configuration();
022     GPIO_Configuration();
023     NVIC_Configuration();
024     USART_Configuration();
025     BKP_Configuration();
026
027
028
029     if(CheckBKP())
030     {
031         printf("\r\n The datas are as their initial status. \r\n");
032         WriteBKP(0xA522,2);
033         PrintBKP();
034     }else{
035         printf("\r\n The datas have been changed . \r\n");
036         WriteBKP(0xA53C,1);
037         PrintBKP();
038     }
039     while(1);
040 }
041
042
043
044
045
046 void GPIO_Configuration(void)
047 {
048     GPIO_InitTypeDef GPIO_InitStructure;
049
050     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
051     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
052     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
053     GPIO_Init(GPIOA , &GPIO_InitStructure);
054
055     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
056     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
057     GPIO_Init(GPIOA , &GPIO_InitStructure);
058 }
059
060 void BKP_Configuration(void)
061 {
062     PWR_BackupAccessCmd(ENABLE);
063     BKP_ClearFlag();
064     BKP_TamperPinLevelConfig(BKP_TamperPinLevel_Low);
065     BKP_ITConfig(ENABLE);
066     BKP_TamperPinCmd(ENABLE);
067 }
068
069
070 void RCC_Configuration(void)
071 {
072     /* 定义枚举类型变量 HSEStartUpStatus */
073     ErrorStatus HSEStartUpStatus;
074
075     /* 复位系统时钟设置*/
076     RCC_DeInit();
077     /* 开启HSE*/
078     RCC_HSEConfig(RCC_HSE_ON);
079     /* 等待HSE起振并稳定*/
080     HSEStartUpStatus = RCC_WaitForHSEStartUp();
081     /* 判断HSE起是否振成功，是则进入if()内部 */
082     if(HSEStartUpStatus == SUCCESS)
083     {
084         /* 选择HCLK（AHB）时钟源为SYSCLK 1分频 */
085         RCC_HCLKConfig(RCC_SYSCLK_Div1);
086         /* 选择PCLK2时钟源为 HCLK（AHB） 1分频 */
087         RCC_PCLK2Config(RCC_HCLK_Div1);
088         /* 选择PCLK1时钟源为 HCLK（AHB） 2分频 */
089         RCC_PCLK1Config(RCC_HCLK_Div2);
090         /* 设置FLASH延时周期数为2 */
091         FLASH_SetLatency(FLASH_Latency_2);
092         /* 使能FLASH预取缓存 */
093         FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
094         /* 选择锁相环（PLL）时钟源为HSE 1分频，倍频数为9，则PLL输出频率为 8MHz * 9 = 72MHz */
095         RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
096         /* 使能PLL */
097         RCC_PLLCmd(ENABLE);
098         /* 等待PLL输出稳定 */
099         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
100         /* 选择SYSCLK时钟源为PLL */
101         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
102         /* 等待PLL成为SYSCLK时钟源 */
103         while(RCC_GetSYSCLKSource() != 0x08);
104     }
105     /* 打开APB2总线上的GPIOA时钟*/
106     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);
107
108     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP, ENABLE);
109
110 }
111
112
113 void USART_Configuration(void)
114 {
115     USART_InitTypeDef USART_InitStructure;
116     USART_ClockInitTypeDef USART_ClockInitStructure;
117
118     USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
119     USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
120     USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
121     USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
122     USART_ClockInit(USART1 , &USART_ClockInitStructure);
123
124     USART_InitStructure.USART_BaudRate = 9600;
125     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
126     USART_InitStructure.USART_StopBits = USART_StopBits_1;
127     USART_InitStructure.USART_Parity = USART_Parity_No;
128     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
129     USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;
130     USART_Init(USART1,&USART_InitStructure);
131
132     USART_Cmd(USART1,ENABLE);
133 }
134
135
136 void NVIC_Configuration(void)
137 {
138     NVIC_InitTypeDef NVIC_InitStructure;
139
140     NVIC_InitStructure.NVIC_IRQChannel = TAMPER_IRQn;
141     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
142     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
143     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
144     NVIC_Init(&NVIC_InitStructure);
145
146 }
147
148 void WriteBKP(u16 Data,u8 DRNumber)       // 还可加入一些加密算法;DRNumber （1-9）
149 {
150     switch(DRNumber)
151     {
152         case 0x01: BKP_WriteBackupRegister(BKP_DR1,Data); break;
153         case 0x02: BKP_WriteBackupRegister(BKP_DR2,Data); break;
154         case 0x03: BKP_WriteBackupRegister(BKP_DR3,Data); break;
155         case 0x04: BKP_WriteBackupRegister(BKP_DR4,Data); break;
156         case 0x05: BKP_WriteBackupRegister(BKP_DR5,Data); break;
157         case 0x06: BKP_WriteBackupRegister(BKP_DR6,Data); break;
158         case 0x07: BKP_WriteBackupRegister(BKP_DR7,Data); break;
159         case 0x08: BKP_WriteBackupRegister(BKP_DR8,Data); break;
160         case 0x09: BKP_WriteBackupRegister(BKP_DR9,Data); break;
161         default:    BKP_WriteBackupRegister(BKP_DR1,Data);
162     }
163     BKP_WriteBackupRegister(BKP_DR10,CHECK_CODE);
164 }
165
166 u8 CheckBKP(void)
167 {
168     if( BKP_ReadBackupRegister(BKP_DR10) == 0xAE86 )   // 如果此位数据丢失，则BPK数据丢失
169         return 1;
170     else
171         return 0;
172 }
173
174 void PrintBKP(void)
175 {
176     printf("DR1 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR1));
177     printf("DR2 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR2));
178     printf("DR3 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR3));
179     printf("DR4 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR4));
180     printf("DR5 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR5));
181     printf("DR6 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR6));
182     printf("DR7 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR7));
183     printf("DR8 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR8));
184     printf("DR9 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR9));
185     printf("DR10 = 0x%04X\t",BKP_ReadBackupRegister(BKP_DR10));
186
187 }
188
189
190 #if  PRINTF_ON
191
192 int fputc(int ch,FILE *f)
193 {
194     USART_SendData(USART1,(u8) ch);
195     while(USART_GetFlagStatus(USART1,USART_FLAG_TC) == RESET);
196     return ch;
197 }
198
199 #endif

 

stm12f10x_it.c

01	#include "stm32f10x_it.h"

02

03	#include "stdio.h"

04

05	extern void PrintBKP(void);

06

07	void TAMPER_IRQHandler(void)

08

{

09	printf("\r\n A Tamper is coming .\r\n");

10	PrintBKP();

11	BKP_ClearITPendingBit();

12	BKP_ClearFlag();

13

14

}