STM32----IAP长途升级

一、概述：

IAP，全称是“In-Application Programming”，中文解释为“在程序中编程”。IAP是一种对通过微控制器的对外接口（如USART，IIC，CAN，USB，以太网接口乃至是无线射频通道）对正在运行程序的微控制器进行内部程序的更新的技能（注意这完全有别于ICP大概ISP技能）。
ICP（In-Circuit Programming）技能即通过在线仿真器对单片机进行程序烧写。
ISP技能则是通过单片机内置的bootloader程序引导的烧写技能。
无论是ICP技能照旧ISP技能，都须要有机械性的利用如毗连下载线，设置跳线帽等。若产物的电路板已经层层密封在外壳中，要对其进行程序更新无疑困难重重，若产物安装于局促空间等难以触及的地方，更是一场灾难。
1、焦点

实现IAP技能的焦点是一段预先烧写在单片机内部的IAP程序。这段程序主要负责与外部的上位机软件进行握手同步，然后将通过外设通信接口将来自于上位机软件的程序数据吸收后写入单片机内部指定的闪存地区，然后再跳转实行新写入的程序，最终就达到了程序更新的目的。
2、简述

在STM32微控制器上实现IAP程序之前首先要回顾一下STM32的内部闪存构造架构和其启动过程。STM32的内部闪存地址起始于0x8000000，一般环境下，程序文件就今后地址开始写入。别的STM32是基于Cortex-M3内核的微控制器，其内部通过一张“中断向量表”来响应中断，程序启动后，将首先从“中断向量表”取出复位中断向量实行复位中断程序完成启动。而这张“中断向量表”的起始地址是0x8000004，当中断来临，STM32的内部硬件机制亦会自动将PC指针定位到“中断向量表”处，并根据中断源取出对应的中断向量实行中断服务程序。末了还须要知道关键的一点，通过修改STM32工程的链接脚本可以修改程序文件写入闪存的起始地址。

                                                                        图1
对图1解读如下：
1、 STM32复位后，会从地址为0x8000004处取出复位中断向量的地址，并跳转实行复位中断服务程序，如图1中标号1所示。
2、 复位中断服务程序实行的最闭幕果是跳转至C程序的main函数，如图1中标号2所示，而main函数应该是一个死循环，是一个永不返回的函数。
3、 在main函数实行的过程中，发生了一个中断请求，此时STM32的硬件机制会将PC指针强制指回中断向量表处，如图1中标号3所示。
4、 根据中断源进入相应的中断服务程序，如图1中标号5所示。
5、 中断服务程序实行完毕后，程序再度返回至main函数中实行，如图1中标号6所示。
 若在STM32中加入了IAP程序，则环境会如图2所示。

                                                                                图2 
对图2的解读如下:
1、 STM32复位后，从地址为0x8000004处取出复位中断向量的地址，并跳转实行复位中断服务程序，随后跳转至IAP程序的main函数，如图2中标号1、2所示。这个过程和图1相应部分是同等的。
2、 实行完IAP过程后（STM32内部多出了新写入的程序，图2中以灰色底纹方格表示，地址始于0x8000004+N+M）跳转至新写入程序的复位向量表，取出新程序的复位中断向量的地址，并跳转实行新程序的复位中断服务程序，随后跳转至新程序的main函数，其过程如图2的标号3所示。新程序的main函数应该也具有永不返回的特性。同时应该注意在STM32的内部存储空间在差别的位置上出现了2个中断向量表。
3、 在新程序main函数实行的过程中，一个中断请求来临，PC指针仍会回转至地址为0x8000004中断向量表处，而并不是新程序的中断向量表，如图2中标号5所示。注意到这是由STM32的硬件机制决定的。
4、 根据中断源跳转至对应的中断服务，如图2中标号6所示。注意此时是跳转至了新程序的中断服务程序中。
5、 中断服务实行完毕后，返回main函数。如图2中标号8所示。
从上述两个过程的分析可以得知，对将利用IAP过程写入的程序要满意2个要求：
1、新程序必须从IAP程序之后的某个偏移量为x的地址开始；
2、必须将新程序的中断向量表相应的移动，移动的偏移量为x；
而设置程序起始位置的方法是（keil uvision5集成开发环境）在工程的“Option for Target….”界面中的“Target”页里将“IROM”的“Start”列改为欲使程序起始的地方，如图3中将程序起始位置设为0x8008000。

                                                                                图3
将中断向量表移动的方法是在程序中加入函数：
void NVIC_SetVectorTable(u32 NVIC_VectTab, u32 Offset)；
其中参数NVIC_VectTab为中断向量表起始位置，而参数Offset则为地址偏移量，如将中断向量表移至0x8008000处，则应调用该函数如下：
void NVIC_SetVectorTable(0x8000000, 0x8000)；
同时有须要提醒读者注意的是，此函数只会修改STM32程序中用于存储中断向量的布局体变量，而不会实质地改变中断向量表在闪存中的物理位置，详情请研究该程序原型。
有了以上预备后就可以动手设计一个IAP方案了，如下：
1、STM32复位后，利用一个按键的状态进行同步，当按键按下时表示将要进行IAP过程；
2、IAP过程中，通过上位机软件向STM32的USART1设备发送所要更新的程序文件，STM32吸收到数据后转而从0x8008000地址开始写入收到的数据；
3、STM32借助定时器来判断数据是否完全吸收，完全吸收后IAP过程结束；
4、再次复位后，跳转0x8008004地址开始运行新写入的程序；
末了提出几点注意事项：
1、详细实现的工程见附件；
2、利用IAP写入的程序文件最好是.bin格式的文件，但不能是.hex格式的文件；
3、向STM32发送程序文件时只管慢一些，因为STM32对FLASH的写入速度每每跟不上通讯外设接口的速度；
4、发起在STM32和上位机之间设计一套握手机制和堕落管理机制，这样可以大幅进步IAP的成功率；
5、附件中的IAP工程详细运行现象为，按着毗连于GPIOA0引脚上的按键后对STM32进行复位利用，若毗连于GPIOA4引脚上的LED被点亮则表示进入了IAP程序，等待从USART1接口传入欲更新的程序文件。程序文件更新完毕后，LED被熄灭。此时再度对STM32进行复位，就开始运行新写入的程序了。
3、bin文件

D:\Keil_v5\ARM\ARMCC\bin\fromelf.exe --bin -o ..\OBJ\APP_LED.bin ..\OBJ\APP_LED.axf
D:\Keil_v5\ARM\ARMCC\bin\fromelf.exe --bin -o :命令表示从可实行文件天生bin文件
\OBJ\APP_LED.bin   ：生产的bin文件的路径和文件名 
\OBJ\APP_LED.axf   ：可实行文件的路径和文件名
二、工程代码

 1、bootloard程序

main.c

1. #include "stdio.h"
2. #include "delay.h"
3. #include "sys.h"
4. #include "usart.h"       
5. #include "LED.h"
6. #include "STM32_FLASH.h"
7. #include "iap.h"
9. int main(void)
10. {               
11.         u8 t=0;
12.         u16 oldcount=0;                                //老的串口接收数据值
13.         u16 applenth=0;                                //接收到的app代码长度
14.          
15.         delay_init();                                                                             //延时函数初始化          
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_3);         //设置NVIC中断分组3:3位抢占优先级(抢占优先级级别可以设置为0级~7级)，1位响应优先级(响应优先级级别可以设置为0级~1级)
17.         uart_init(9600);                                                                         //uart_init初始化为9600
18.         IAP_Switch_IO_Init();                                                                //IAP开关I/O口初始化
19.         LED_Init();
20.         for(;;)
21.         {               
22.                 //如果IAP_Switch_I/O口为低电平时等待接收串口发送的APP程序
23.                 if(1 == IAP_Switch_IO_In)
24.                 {
25.                         //接收的字节数
26.                         if(USART_RX_CNT)
27.                         {
28.                                 if(oldcount==USART_RX_CNT)//新周期内,没有收到任何数据,认为本次数据接收完成.
29.                                 {
30.                                         applenth=USART_RX_CNT;
31.                                         oldcount=0;
32.                                         USART_RX_CNT=0;
33.                                         printf("用户程序接收完成!\r\n");
34.                                         printf("代码长度:%dBytes\r\n",applenth);
35.                                 }
36.                                 else
37.                                 {
38.                                         oldcount=USART_RX_CNT;               
39.                                 }               
40.                         }
41.                         LED1=!LED1;         
42.                        
43.                         if(applenth)
44.                         {
45.                                 printf("开始更新固件...\r\n");       
46.                                
47.                                 //SRAM在(0X20001000+4)的地址处保存了APP程序的复位中断向量(复位中断服务函数的入口地址)
48.                                 if( ((*(vu32*)(0X20001000+4)) >= 0x08000000) && ((*(vu32*)(0X20001000+4)) < 0x08040000))
49.                                 {         
50.                                         iap_write_appbin(FLASH_APP1_ADDR,USART_RX_BUF,applenth);//更新FLASH代码   
51.                                         printf("固件更新完成!\r\n");       
52.                                         applenth = 0;
53.                                 }
54.                                 else
55.                                 {   
56.                                         printf("非FLASH应用程序!\r\n");
57.                                 }
58.                         }
59.                         else
60.                         {
61.                                 printf("没有可以更新的固件!\r\n");
62.                                 delay_ms(1000);
63.                         }
64.                 }
65.                
66.                 //如果IAP_Switch_I/O口为高电平时开始执行APP程序
67.                 if(0 == IAP_Switch_IO_In)
68.                 {
69.                         //开始执行FLASH用户代码,先要判断我们要跳转的APP地址是否合法
70.                         //FALSH在(FLASH_APP1_ADDR+4)的地址处保存了APP程序的复位中断向量(复位中断服务函数的入口地址)
71.                         if((*(vu32*)(FLASH_APP1_ADDR+4) >= 0x08000000) && (*(vu32*)(FLASH_APP1_ADDR+4) < 0x08040000))
72.                         {         
73.                                 printf("开始执行FLASH用户代码!!\r\n");
74.                                 iap_load_app(FLASH_APP1_ADDR);//执行FLASH APP代码
75.                         }
76.                         else
77.                         {
78.                                 printf("非FLASH应用程序,无法执行!\r\n");   
79.                         }
80.                 }
81.         }
82. }

复制代码

 iap.c

1. #include "stdio.h"
2. #include "delay.h"
3. #include "sys.h"
4. #include "usart.h"       
5. #include "LED.h"
6. #include "STM32_FLASH.h"
7. #include "iap.h"
9. iapfun jump2app;
10. u16 iapbuf[1024];   
11. //appxaddr:应用程序的起始地址
12. //appbuf:应用程序CODE.
13. //appsize:应用程序大小(字节).
14. void iap_write_appbin(u32 appxaddr,u8 *appbuf,u32 appsize)
15. {
16.         u16 t;
17.         u16 i=0;
18.         u16 temp;
19.         u32 fwaddr=appxaddr;//当前写入的地址
20.         u8 *dfu=appbuf;
21.         for(t=0;t<appsize;t+=2)
22.         {                                                    
23.                 temp=(u16)dfu[1]<<8;
24.                 temp+=(u16)dfu[0];          
25.                 dfu+=2;//偏移2个字节
26.                 iapbuf[i++]=temp;            
27.                 if(i==1024)
28.                 {
29.                         i=0;
30.                         STMFLASH_Write(fwaddr,iapbuf,1024);       
31.                         fwaddr+=2048;//偏移2048  16=2*8.所以要乘以2.
32.                 }
33.         }
34.         if(i)STMFLASH_Write(fwaddr,iapbuf,i);//将最后的一些内容字节写进去.  
35. }
37. //跳转到应用程序段
38. //appxaddr:用户代码起始地址.
39. void iap_load_app(u32 appxaddr)
40. {
41.         //STM32F103RCT6的SRAM为48k Byte，即0xC000 Byte。故SRAM的地址范围为0x20000000~0x2000BFFF,在此外的范围都是不合法的
42.         //appxaddr为APP程序的起始地址，FLASH在此地址处保存了栈顶地址,范围为0x20000000~0x2000BFFF
43.         if((*(vu32*)appxaddr)>=0x20000000 && (*(vu32*)appxaddr)<0x2000C000)
44.         //(((*(vu32*)appxaddr)&0x2FFE0000)==0x20000000)
45.         {
46.                 jump2app=(iapfun)*(vu32*)(appxaddr+4);                //用户APP代码区第二个字为程序开始地址(复位中断服务函数的入口地址)        复位中断服务函数的入口地址       
47.                 MSR_MSP(*(vu32*)appxaddr);                                                                //初始化APP堆栈指针(用户APP代码区的第一个字用于存放栈顶地址) 通过函数指针 jump2app 跳转到用户应用程序的入口地址，开始执行应用程序。
48.                 jump2app();                                                                                                                                //跳转到APP.（函数指针）
49.         }
50. }                 
52. //IAP开关I/O口初始化
53. void IAP_Switch_IO_Init(void)
54. {
55.         GPIO_InitTypeDef  GPIO_InitStructure;
57.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);         //使能PC端口时钟
59.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;                                 //PC4端口配置
60.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                         //上拉输入
61.         GPIO_Init(GPIOC, &GPIO_InitStructure);                                        //根据设定参数初始化GPIOC
63. }       

复制代码

iap.h

1. #ifndef _IAP_H_
2. #define _IAP_H_
4. #include "stdio.h"
5. #include "delay.h"
6. #include "sys.h"
7. #include "usart.h"       
8. #include "LED.h"
9. #include "STM32_FLASH.h"
10. #include "iap.h"
12. #define IAP_Switch_IO_In                        PCin(4)                                                        //IAP开关I/O口
14. #define FLASH_APP1_ADDR                0x08008000                                                          //第一个APP应用程序起始地址(存放在FLASH)
15.                                                                                                                                         //保留0X08000000~0X08007FFF的空间为Bootloader使用（32KB）          
17. typedef  void (*iapfun)(void);                                                                                //定义一个函数类型的参数.
19. void iap_load_app(u32 appxaddr);                                                                        //执行flash里面的app程序
20. void iap_load_appsram(u32 appxaddr);                                                                //执行sram里面的app程序
21. void iap_write_appbin(u32 appxaddr,u8 *appbuf,u32 applen);                        //在指定地址开始,写入bin
23. void IAP_Switch_IO_Init(void);                                                                                //IAP开关I/O口初始化
25. #endif

复制代码

STM32_FLASH.c

1. #include "stdio.h"
2. #include "delay.h"
3. #include "sys.h"
4. #include "usart.h"       
5. #include "LED.h"
6. #include "STM32_FLASH.h"
7. #include "iap.h"
9. //解锁STM32的FLASH
10. void STMFLASH_Unlock(void)                                                                                //void FLASH_Unlock(void)（官方库）
11. {
12.   FLASH->KEYR=FLASH_KEY1;//写入解锁序列.
13.   FLASH->KEYR=FLASH_KEY2;
14. }
15. //flash上锁
16. void STMFLASH_Lock(void)
17. {
18.   FLASH->CR|=1<<7;//上锁
19. }
20. //得到FLASH状态
21. u8 STMFLASH_GetStatus(void)
22. {       
23.         u32 res;               
24.         res=FLASH->SR;
25.         if(res&(1<<0))return 1;                    //忙
26.         else if(res&(1<<2))return 2;        //编程错误
27.         else if(res&(1<<4))return 3;        //写保护错误
28.         return 0;                                                //操作完成
29. }
30. //等待操作完成
31. //time:要延时的长短
32. //返回值:状态.
33. u8 STMFLASH_WaitDone(u16 time)
34. {
35.         u8 res;
36.         do
37.         {
38.                 res=STMFLASH_GetStatus();
39.                 if(res!=1)break;//非忙,无需等待了,直接退出.
40.                 delay_us(1);
41.                 time--;
42.          }while(time);
43.          if(time==0)res=0xff;//TIMEOUT
44.          return res;
45. }
46. //擦除页
47. //paddr:页地址
48. //返回值:执行情况
49. u8 STMFLASH_ErasePage(u32 paddr)                                        //FLASH_Status FLASH_ErasePage(uint32_t Page_Address);官方库
50. {
51.         u8 res=0;
52.         res=STMFLASH_WaitDone(0X5FFF);//等待上次操作结束,>20ms   
53.         if(res==0)
54.         {
55.                 FLASH->CR|=1<<1;//页擦除
56.                 FLASH->AR=paddr;//设置页地址
57.                 FLASH->CR|=1<<6;//开始擦除                  
58.                 res=STMFLASH_WaitDone(0X5FFF);//等待操作结束,>20ms  
59.                 if(res!=1)//非忙
60.                 {
61.                         FLASH->CR&=~(1<<1);//清除页擦除标志.
62.                 }
63.         }
64.         return res;
65. }
66. //在FLASH指定地址写入半字
67. //faddr:指定地址(此地址必须为2的倍数!!)
68. //dat:要写入的数据
69. //返回值:写入的情况
70. u8 STMFLASH_WriteHalfWord(u32 faddr, u16 dat)                        //FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);                       
71. {
72.         u8 res;                       
73.         res=STMFLASH_WaitDone(0XFF);         
74.         if(res==0)//OK
75.         {
76.                 FLASH->CR|=1<<0;//编程使能
77.                 *(vu16*)faddr=dat;//写入数据
78.                 res=STMFLASH_WaitDone(0XFF);//等待操作完成
79.                 if(res!=1)//操作成功
80.                 {
81.                         FLASH->CR&=~(1<<0);//清除PG位.
82.                 }
83.         }
84.         return res;
85. }
86. //读取指定地址的半字(16位数据)
87. //faddr:读地址
88. //返回值:对应数据.
89. u16 STMFLASH_ReadHalfWord(u32 faddr)                                                        //FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data);
90. {
91.         return *(vu16*)faddr;
92. }
93. #if STM32_FLASH_WREN        //如果使能了写   
94. //不检查的写入
95. //WriteAddr:起始地址
96. //pBuffer:数据指针
97. //NumToWrite:半字(16位)数   
98. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
99. {                                           
100.         u16 i;
101.         for(i=0;i<NumToWrite;i++)
102.         {
103.                 STMFLASH_WriteHalfWord(WriteAddr,pBuffer[i]);
104.             WriteAddr+=2;//地址增加2.
105.         }  
106. }
107. //从指定地址开始写入指定长度的数据
108. //WriteAddr:起始地址(此地址必须为2的倍数!!)
109. //pBuffer:数据指针
110. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)
111. #if STM32_FLASH_SIZE<256
112. #define STM_SECTOR_SIZE 1024 //字节
113. #else
114. #define STM_SECTOR_SIZE        2048
115. #endif                 
116. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];//最多是2K字节
117. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)       
118. {
119.         u32 secpos;           //扇区地址
120.         u16 secoff;           //扇区内偏移地址(16位字计算)
121.         u16 secremain; //扇区内剩余地址(16位字计算)          
122.         u16 i;   
123.         u32 offaddr;   //去掉0X08000000后的地址
124.         if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
125.         STMFLASH_Unlock();                                                //解锁
126.         offaddr=WriteAddr-STM32_FLASH_BASE;                //实际偏移地址.
127.         secpos=offaddr/STM_SECTOR_SIZE;                        //扇区地址  0~127 for STM32F103RBT6
128.         secoff=(offaddr%STM_SECTOR_SIZE)/2;                //在扇区内的偏移(2个字节为基本单位.)
129.         secremain=STM_SECTOR_SIZE/2-secoff;                //扇区剩余空间大小   
130.         if(NumToWrite<=secremain)secremain=NumToWrite;//不大于该扇区范围
131.         while(1)
132.         {       
133.                 STMFLASH_Read(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
134.                 for(i=0;i<secremain;i++)//校验数据
135.                 {
136.                         if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除            
137.                 }
138.                 if(i<secremain)//需要擦除
139.                 {
140.                         STMFLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
141.                         for(i=0;i<secremain;i++)//复制
142.                         {
143.                                 STMFLASH_BUF[i+secoff]=pBuffer[i];          
144.                         }
145.                         STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区  
146.                 }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                   
147.                 if(NumToWrite==secremain)break;//写入结束了
148.                 else//写入未结束
149.                 {
150.                         secpos++;                                //扇区地址增1
151.                         secoff=0;                                //偏移位置为0          
152.                            pBuffer+=secremain;          //指针偏移
153.                         WriteAddr+=secremain*2;        //写地址偏移(16位数据地址,需要*2)          
154.                            NumToWrite-=secremain;        //字节(16位)数递减
155.                         if(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
156.                         else secremain=NumToWrite;//下一个扇区可以写完了
157.                 }         
158.         };       
159.         STMFLASH_Lock();//上锁
160. }
161. #endif
162. //从指定地址开始读出指定长度的数据
163. //ReadAddr:起始地址
164. //pBuffer:数据指针
165. //NumToWrite:半字(16位)数
166. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)          
167. {
168.         u16 i;
169.         for(i=0;i<NumToRead;i++)
170.         {
171.                 pBuffer[i]=STMFLASH_ReadHalfWord(ReadAddr);//读取2个字节.
172.                 ReadAddr+=2;//偏移2个字节.       
173.         }
174. }
176. //测试用///
177. //WriteAddr:起始地址
178. //WriteData:要写入的数据
179. void Test_Write(u32 WriteAddr,u16 WriteData)          
180. {
181.         STMFLASH_Write(WriteAddr,&WriteData,1);//写入一个字
182. }

复制代码

STM32_FLASH.h

1. #ifndef _STM32_FLASH_H_
2. #define _STM32_FLASH_H_       
4. #include "stdio.h"
5. #include "delay.h"
6. #include "sys.h"
7. #include "usart.h"       
8. #include "LED.h"
9. #include "STM32_FLASH.h"
10. #include "iap.h"
12. //
13. //用户根据自己的需要设置
14. #define STM32_FLASH_SIZE         256                                  //所选STM32的FLASH容量大小(单位为K)
15. #define STM32_FLASH_WREN         1                              //使能FLASH写入(0，不是能;1，使能)
16. //
18. //FLASH起始地址
19. #define STM32_FLASH_BASE 0x08000000                         //STM32 FLASH的起始地址
20. //FLASH解锁键值
21. #define FLASH_KEY1               0X45670123
22. #define FLASH_KEY2               0XCDEF89AB
23. void STMFLASH_Unlock(void);                                                  //FLASH解锁
24. void STMFLASH_Lock(void);                                                  //FLASH上锁
25. u8 STMFLASH_GetStatus(void);                                          //获得状态
26. u8 STMFLASH_WaitDone(u16 time);                                          //等待操作结束
27. u8 STMFLASH_ErasePage(u32 paddr);                                  //擦除页
28. u8 STMFLASH_WriteHalfWord(u32 faddr, u16 dat);        //写入半字
29. u16 STMFLASH_ReadHalfWord(u32 faddr);                          //读出半字  
30. void STMFLASH_WriteLenByte(u32 WriteAddr,u32 DataToWrite,u16 Len);        //指定地址开始写入指定长度的数据
31. u32 STMFLASH_ReadLenByte(u32 ReadAddr,u16 Len);                                                //指定地址开始读取指定长度数据
32. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite);                //从指定地址开始写入指定长度的数据
33. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead);                   //从指定地址开始读出指定长度的数据
35. //测试写入
36. void Test_Write(u32 WriteAddr,u16 WriteData);       
38. #endif

复制代码

2、APP程序

main.c
APP程序没什么特点，只须要在“Target”里面和“main.c”更改一下中断向量表位置即可；

1. #include "led.h"
2. #include "delay.h"
3. #include "sys.h"
4. #include "stdio.h"
5. #include "usart.h"
7. //GPIO输入实验  
8. //技术支持：
9. int i;
10. int main(void)
11. {
12.         u8 t;
13.         /* Vector Table Relocation in Internal FLASH. */
14.         SCB->VTOR = FLASH_BASE | 0x8000;//中断向量表偏移量，基地址加偏移量
15.         uart_init(9600);
16.         delay_init();            //延时函数初始化          
17.         LED_Init();                          //初始化LED
18.         while(1)
19.         {
20.                 //LED1=0;//PA6 输出低电平 LED1亮
21.                 //LED2=1;//PA7 输出高电平 LED2灭
22. //                GPIO_ResetBits(GPIOA,GPIO_Pin_6); //PA6 输出低电平 LED1亮
23. //                GPIO_SetBits(GPIOA,GPIO_Pin_7);   //PA7 输出高电平 LED2灭
24. //                delay_ms(300);
25. //                //LED1=1;//PA6 输出高电平 LED1灭
26. //                //LED2=0;//PA7 输出低电平 LED2亮
27. //                GPIO_SetBits(GPIOA,GPIO_Pin_6);  //PA6 输出高电平 LED1灭
28. //                GPIO_ResetBits(GPIOA,GPIO_Pin_7);//PA7 输出低电平 LED2亮
29. //                delay_ms(300);
30.         
31.              for(i=1;i<1500;i++)//    for(i=1;i<1500;i++)
32.             {
33.                 GPIO_SetBits(GPIOA,GPIO_Pin_6|GPIO_Pin_7);                 
34.                 delay_us(i);
35.                 GPIO_ResetBits(GPIOA,GPIO_Pin_7|GPIO_Pin_6);
36.                 delay_us(1500-i);
37.             }
38.             for(i=1;i<1500;i++)
39.             {
40.                  GPIO_ResetBits(GPIOA,GPIO_Pin_7|GPIO_Pin_6);
41.                 delay_us(i);
42.                 GPIO_SetBits(GPIOA,GPIO_Pin_6|GPIO_Pin_7);
43.                 delay_us(1500-i);
44.             }
45.                 BEEP = !BEEP;
46.                 printf("t = %d\r\n",t);
47.                 t++;
48.         }
49. }

复制代码