[STM32入门篇]第九课 构建库函数雏形点亮LED 作业汇总

GCT

入门第九课《自己写库—构建库函数雏形》课后作业汇总

    入门篇 第九课内所有题目：

    9.1

   

    9.3

   

    使用新的库函数的方案继续优化之前的led灯闪烁程序

   

    目标：简化宏定义部分。如果对于每个外设都去写对于基地址物理地址的宏定义，要去写指针还要去翻参考手册，会特别麻烦。

    看过参考手册可以对外设总结出一个共性：所有的寄存器都占用32byte，而且地址连续排列。有没有一种方式能替换这些宏定义？

    C语言有一种结构叫做结构体，它包含的数据成员可以是不同类型的，最重要的是，它的物理地址是对齐的连续排列的。

   

    结构体的存放特性恰好迎合了我们对于外设寄存器的需求：大小相同，连续排列

    可以将上面的宏定义修改成结构体的定义：

    首先先定义两个新的类型：uint32_t和uint16_t。uint16_t用来定义16bit类型，c语言的short类型恰好大小为2byte；

    uint32_t用来定义32bit类型，c语言的int类型恰好大小为4byte。取个别名应该是为了统一便于编程，u代表unsigned，就不需要写那么多遍unsigned了。

   

    RCC时钟的寄存器如下：

       

    结构体定义如下：

       

    注意：不管是否要用到，必须写上所有的寄存器！一定要写全！因为地址是连续的，如果不写的话寄存器对应的地址就错了！

    定义完结构体以后需要告诉程序定义的结构体首地址应该在哪里。RCC_BASE基地址之前已经定义好了，但是程序不知道这个是RCC外设的基地址。

   

    使用c语言方法将这个地址（宏定义完还是立即数）强制转换为结构体RCC_TypeDef的指针，告诉它你是一个地址，应该指向结构体。

    用相同的方法定义GPIO寄存器：

   

   

    完整头文件stm32f10x.h代码如下：

1. #ifndef __STM32F10X_H
   
2. #define __STM32F10X_H
   
3. 
   
4. //用来存放STM32寄存器映射的代码
   
5. //外设 peripheral
   
6. 
   
7. #define PERIPH_BASE        ((unsigned int)0x40000000)
   
8. #define APB2PERIPH_BASE    (PERIPH_BASE + 0x10000)
   
9. #define AHBPERIPH_BASE     (PERIPH_BASE + 0x20000)
   
10. 
    
11. #define RCC_BASE           (AHBPERIPH_BASE+0x1000)
    
12. #define GPIOB_BASE          (APB2PERIPH_BASE+0x0C00)
    
13. 
    
14. typedef unsigned int   uint32_t;
    
15. typedef unsigned short uint16_t;
    
16. 
    
17. typedef struct
    
18. {
    
19.     uint32_t CR;
    
20.     uint32_t CFGR;
    
21.     uint32_t CIR;
    
22.     uint32_t APB2RSTR;
    
23.     uint32_t APB1RSTR;
    
24.     uint32_t AHBENR;
    
25.     uint32_t APB2ENR;
    
26.     uint32_t APB1ENR;
    
27.     uint32_t BDCR;
    
28.     uint32_t CSR;
    
29. }RCC_TypeDef;
    
30. 
    
31. #define RCC ((RCC_TypeDef*)RCC_BASE)
    
32. 
    
33. typedef struct
    
34. {
    
35.     uint32_t CRL;
    
36.     uint32_t CRH;
    
37.     uint32_t IDR;
    
38.     uint32_t ODR;
    
39.     uint32_t BSRR;
    
40.     uint32_t BRR;
    
41.     uint32_t LCKR;
    
42. }GPIO_TypeDef;
    
43. 
    
44. #define GPIOB ((GPIO_TypeDef*)GPIOB_BASE)
    
45. 
    
46. #endif /*__STM32F10X_H*/
    

复制代码

      现在可以用结构体指针访问修改寄存器了，方法：<结构体指针名> -> <寄存器名>。之前宏定义的别名就可以不需要了。
      修改优化后的红蓝闪烁代码如下：

1. #include "stm32f10x.h"
   
2. #include "stm32f10x_gpio.h"
   
3. 
   
4. #define Red 5
   
5. #define Green 0
   
6. #define Blue 1
   
7. 
   
8. void delay_us(int delay_us);
   
9. void delay_ms(int delay_ms);
   
10. void initial(int clp);
    
11. void ledBlink(int cl);
    
12. 
    
13. int main(void)
    
14. {
    
15.     RCC->APB2ENR |=(1<<3);
    
16. 
    
17.     while(1)
    
18.     {
    
19.         initial(Red);
    
20.         ledBlink(Red);
    
21. 
    
22.         initial(Blue);
    
23.         ledBlink(Blue);
    
24.     }
    
25. }
    
26. 
    
27. //函数体为空，目的是为了骗过编译器不报错
    
28. void SystemInit(void)
    
29. {}
    
30. 
    
31. //微秒级的延时
    
32. void delay_us(int delay_us)
    
33. {
    
34.     volatile unsigned int num;
    
35.     volatile unsigned int t;
    
36. 
    
37.     for (num = 0; num < delay_us; num++)
    
38.     {
    
39.         t = 11;
    
40.         while (t != 0)
    
41.         {
    
42.             t--;
    
43.         }
    
44.     }
    
45. }
    
46. //毫秒级的延时
    
47. void delay_ms(int delay_ms)
    
48. {
    
49.     volatile unsigned int num;
    
50.     for (num = 0; num < delay_ms; num++)
    
51.     {
    
52.         delay_us(1000);
    
53.     }
    
54. }
    
55. 
    
56. void initial(int clp)
    
57. {
    
58.     GPIOB->CRL &=~((0x0F)<<(4*clp));
    
59.     GPIOB->CRL |=(1<<(4*clp));
    
60. }
    
61. 
    
62. void ledBlink(int cl)
    
63. {
    
64.     GPIOB->BSRR &=~(1<<cl);
    
65.     delay_ms(100);
    
66.     GPIOB->BRR &=~(1<<cl);
    
67.     GPIOB->CRL &=~((0x0F)<<(4*cl));
    
68. }
    

复制代码

      目标：优化寄存器操作部分，使代码可读性增强。如果寄存器修改使用|=1<<(4*cl)这样的方法，对于其他开发人员如果没有注释和参考手册，很难理解要干什么。
      而且，使用结构体以后，main.c并没有得到真正的优化，只是别名改了而已。

      创建新的文件：stm32f10x_gpio.c，用来存放封装寄存器操作的函数；其对应的头文件stm32f10x_gpio.h，用来存放对于外设硬件方面的宏定义
      （一般对于硬件有关的 直接进行宏定义）
      在写头文件的宏定义之前，有一点规范是需要注意的。
              
      当头文件一多以后，难免会出现相互引用的情况，这样编译就会报错说重复定义。
      解决方法是每次写头文件的时候先写三句宏定义，再写别的定义：
      #ifndef __<头文件名字 全大写>_H

      #define __<头文件名字 全大写>_H
      xxx（此处写其他定义）

      #endif /*__<头文件名字 全大写>_H*/
      也算是一种江湖规矩


      有些定义和函数声明需要用到结构体定义，所以先要包含主头文件stm32f10x.h
      

      我先对所有的GPIOA-GPIOG进行了定义，为的是方便进行时钟的设置。
      

      然后定义了用于设置GPIO不同引脚模式的宏（后面课上讲了更好的方法——用枚举类型 灵活性好），这里所有口默认设置为推挽输出，10MHz
      

      最后定义用于控制具体端口输入输出内容的宏：
      


      下面先开始写函数部分，在stm32f10x_gpio.c
      先包含它的专属头文件：stm32f10x_gpio.h
      弄清需要那些功能：RCC时钟设置、清空CRL、CRL设置模式、位“置1”、位“清除”。
      总体如下：
      

      因为是模拟的库函数，有些名字是我自己起的，可能和库函数的不一致。

      函数定义需要写到头文件，便于main.c调用

      RCC时钟设置函数（RCC_Enable()）：
      参数：RCC寄存器地址，GPIO端口选哪一个
      函数内容：相应RCC寄存器置1操作使能时钟，对应原来的RCC->APB2ENR |= (1<<3);

      

      CRL清空函数(GPIO_ClearRL())：
      函数内容：清空对应GPIO引脚的初始值或给定值，为的是让后续的按位或 置1操作能够顺利进行不出错（防止出现例如之前的按位或之后变成开漏输出的情况）。
      

      CRL配置函数(GPIO_ConfigRL())：
      函数内容：配置对应GPIO引脚为推挽输出、10MHz（设定成默认值，现在不能选择其他选项）
      

      BSRR位设置函数(GPIO_SetBits())：

      函数内容：配置对应GPIO引脚输出高电平（LED关）
      

      BRR位设置函数(GPIO_ResetBits())：
      函数内容：配置对应GPIO引脚输出低电平（LED开）
      

      经过优化后的完整红蓝闪烁代码：
      stm32f10x_gpio.c：

1. #include "stm32f10x_gpio.h"
   
2. 
   
3. void RCC_Enable(RCC_TypeDef *RCCx,uint16_t IOPortx)
   
4. {
   
5.     RCCx->APB2ENR |=IOPortx;
   
6. }
   
7. void GPIO_ClearRL(GPIO_TypeDef *GPIOx,uint32_t GPIO_Pin)
   
8. {
   
9.     GPIOx->CRL &=~GPIO_Pin;
   
10. }
    
11. void GPIO_ConfigRL(GPIO_TypeDef *GPIOx,uint32_t GPIO_Pin)
    
12. {
    
13.     GPIOx->CRL |=GPIO_Pin;
    
14. }
    
15. 
    
16. void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin)
    
17. {
    
18.     GPIOx->BSRR |= GPIO_Pin;
    
19. }
    
20. 
    
21. void GPIO_ResetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin)
    
22. {
    
23.     GPIOx->BRR |= GPIO_Pin;
    
24. }
    
25. 
    

复制代码

      stm32f10x_gpio.h：

1. #ifndef __STM32F10X_GPIO_H
   
2. #define __STM32F10X_GPIO_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   
6. #define IOPortA ((uint16_t)0x0004) //GPIOA
   
7. #define IOPortB ((uint16_t)0x0008) //GPIOB
   
8. #define IOPortC ((uint16_t)0x0010) //GPIOC
   
9. #define IOPortD ((uint16_t)0x0020) //GPIOD
   
10. #define IOPortE ((uint16_t)0x0040) //GPIOE
    
11. #define IOPortF ((uint16_t)0x0080) //GPIOF
    
12. #define IOPortG ((uint16_t)0x0100) //GPIOG
    
13. 
    
14. #define GPIOCFG_Pin0   ((uint32_t)0x00000001) //设置Pin0
    
15. #define GPIOCFG_Pin1   ((uint32_t)0x00000010) //设置Pin1
    
16. #define GPIOCFG_Pin2   ((uint32_t)0x00000100) //设置Pin2
    
17. #define GPIOCFG_Pin3   ((uint32_t)0x00001000) //设置Pin3
    
18. #define GPIOCFG_Pin4   ((uint32_t)0x00010000) //设置Pin4
    
19. #define GPIOCFG_Pin5   ((uint32_t)0x00100000) //设置Pin5
    
20. #define GPIOCFG_Pin6   ((uint32_t)0x01000000) //设置Pin6
    
21. #define GPIOCFG_Pin7   ((uint32_t)0x10000000) //设置Pin7
    
22. 
    
23. #define GPIO_Pin0   ((uint16_t)0x0001) //选择Pin0
    
24. #define GPIO_Pin1   ((uint16_t)0x0002) //选择Pin1
    
25. #define GPIO_Pin2   ((uint16_t)0x0004) //选择Pin2
    
26. #define GPIO_Pin3   ((uint16_t)0x0008) //选择Pin3
    
27. #define GPIO_Pin4   ((uint16_t)0x0010) //选择Pin4
    
28. #define GPIO_Pin5   ((uint16_t)0x0020) //选择Pin5
    
29. #define GPIO_Pin6   ((uint16_t)0x0040) //选择Pin6
    
30. #define GPIO_Pin7   ((uint16_t)0x0080) //选择Pin7
    
31. 
    
32. #define GPIO_Pin8   ((uint16_t)0x0100) //选择Pin8
    
33. #define GPIO_Pin9   ((uint16_t)0x0200) //选择Pin9
    
34. #define GPIO_Pin10  ((uint16_t)0x0400) //选择Pin10
    
35. #define GPIO_Pin11  ((uint16_t)0x0800) //选择Pin11
    
36. #define GPIO_Pin12  ((uint16_t)0x1000) //选择Pin12
    
37. #define GPIO_Pin13  ((uint16_t)0x2000) //选择Pin13
    
38. #define GPIO_Pin14  ((uint16_t)0x4000) //选择Pin14
    
39. #define GPIO_Pin15  ((uint16_t)0x8000) //选择Pin15
    
40. #define GPIO_PinAll ((uint16_t)0xFFFF) //选择全部Pin
    
41. 
    
42. void RCC_Enable(RCC_TypeDef *RCCx,uint16_t IOPortx);
    
43. void GPIO_ClearRL(GPIO_TypeDef *GPIOx,uint32_t GPIO_Pin);
    
44. void GPIO_ConfigRL(GPIO_TypeDef *GPIOx,uint32_t GPIO_Pin);
    
45. void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin);
    
46. void GPIO_ResetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin);
    
47. 
    
48. #endif /*__STM32F10X_GPIO_H*/
    
49. 
    

复制代码

      stm32f10x.h：

1. #ifndef __STM32F10X_H
   
2. #define __STM32F10X_H
   
3. //用来存放STM32寄存器映射的代码
   
4. 
   
5. //外设 peripheral
   
6. 
   
7. #define PERIPH_BASE        ((unsigned int)0x40000000)
   
8. //#define APB1PERIPH_BASE    PERIPH_BASE
   
9. #define APB2PERIPH_BASE    (PERIPH_BASE + 0x10000)
   
10. #define AHBPERIPH_BASE     (PERIPH_BASE + 0x20000)
    
11. 
    
12. #define RCC_BASE           (AHBPERIPH_BASE+0x1000)
    
13. #define GPIOB_BASE          (APB2PERIPH_BASE+0x0C00)
    
14. 
    
15. #define RCC_APB2ENR        *(unsigned int*)(RCC_BASE + 0x18)
    
16.    
    
17. #define GPIOB_CRL           *(unsigned int*)(GPIOB_BASE + 0x00)
    
18. #define GPIOB_CRH           *(unsigned int*)(GPIOB_BASE + 0x04)
    
19. #define GPIOB_IDR           *(unsigned int*)(GPIOB_BASE + 0x08)
    
20. #define GPIOB_ODR           *(unsigned int*)(GPIOB_BASE + 0x0C)
    
21. #define GPIOB_BSRR          *(unsigned int*)(GPIOB_BASE + 0x10)
    
22. #define GPIOB_BRR           *(unsigned int*)(GPIOB_BASE + 0x14)
    
23. #define GPIOB_LCKR          *(unsigned int*)(GPIOB_BASE + 0x18)
    
24. 
    
25. typedef unsigned int   uint32_t;
    
26. typedef unsigned short uint16_t;
    
27. 
    
28. typedef struct
    
29. {
    
30.     uint32_t CR;
    
31.     uint32_t CFGR;
    
32.     uint32_t CIR;
    
33.     uint32_t APB2RSTR;
    
34.     uint32_t APB1RSTR;
    
35.     uint32_t AHBENR;
    
36.     uint32_t APB2ENR;
    
37.     uint32_t APB1ENR;
    
38.     uint32_t BDCR;
    
39.     uint32_t CSR;
    
40. }RCC_TypeDef;
    
41. 
    
42. #define RCC ((RCC_TypeDef*)RCC_BASE)
    
43. 
    
44. typedef struct
    
45. {
    
46.     uint32_t CRL;
    
47.     uint32_t CRH;
    
48.     uint32_t IDR;
    
49.     uint32_t ODR;
    
50.     uint32_t BSRR;
    
51.     uint32_t BRR;
    
52.     uint32_t LCKR;
    
53. }GPIO_TypeDef;
    
54. 
    
55. #define GPIOB ((GPIO_TypeDef*)GPIOB_BASE)
    
56. 
    
57. #endif /*__STM32F10X_H*/
    
58. 
    

复制代码

      main.c

1. #include "stm32f10x.h"
   
2. #include "stm32f10x_gpio.h"
   
3. 
   
4. #define Red GPIO_Pin5
   
5. #define Green GPIO_Pin0
   
6. #define Blue GPIO_Pin1
   
7. 
   
8. #define RedCfg GPIOCFG_Pin5
   
9. #define GreenCfg GPIOCFG_Pin0
   
10. #define BlueCfg GPIOCFG_Pin1
    
11. 
    
12. void delay_us(int delay_us);
    
13. void delay_ms(int delay_ms);
    
14. void initial(int clp);
    
15. void ledBlink(int cl);
    
16. 
    
17. int main(void)
    
18. {
    
19.     RCC_Enable(RCC,IOPortB);
    
20.     while(1)
    
21.     {
    
22.         initial(RedCfg);
    
23.         ledBlink(Red);
    
24.         initial(BlueCfg);
    
25.         ledBlink(Blue);
    
26.     }
    
27. }
    
28. 
    
29. //函数体为空，目的是为了骗过编译器不报错
    
30. void SystemInit(void)
    
31. {}
    
32. 
    
33. //微秒级的延时
    
34. void delay_us(int delay_us)
    
35. {
    
36.     volatile unsigned int num;
    
37.     volatile unsigned int t;
    
38. 
    
39.     for (num = 0; num < delay_us; num++)
    
40.     {
    
41.         t = 11;
    
42.         while (t != 0)
    
43.         {
    
44.             t--;
    
45.         }
    
46.     }
    
47. }
    
48. //毫秒级的延时
    
49. void delay_ms(int delay_ms)
    
50. {
    
51.     volatile unsigned int num;
    
52.     for (num = 0; num < delay_ms; num++)
    
53.     {
    
54.         delay_us(1000);
    
55.     }
    
56. }
    
57. 
    
58. void initial(int clp)
    
59. {
    
60.     GPIO_ClearRL(GPIOB,(clp*(0xf)));
    
61.     GPIO_ConfigRL(GPIOB,clp);
    
62. }
    
63. 
    
64. void ledBlink(int cl)
    
65. {
    
66.     GPIO_ResetBits(GPIOB,cl);
    
67.     delay_ms(100);
    
68.     GPIO_SetBits(GPIOB,cl);
    
69.     GPIO_ClearRL(GPIOB,(cl*(0x4)));
    
70. }
    

复制代码

      

      这样修改以后还是可读性增强了不少，但是还是有些不足比如模式不能选择。
      GPIO配置中，输入输出模式有八种分别是：模拟输入、浮空输入、下拉输入、上拉输入、开漏输出、推挽输出、复用开漏输出、复用推挽输出。
      输出速度速度有三种：10mhz、2mhz、50mhz。
      可以通过定义enum枚举类型来限定选项。


      输入输出模式枚举类型：
      

      输出速度枚举类型：
      

      再定义一个初始化结构体类型，存放初始化GPIO引脚要用到的三个参数：引脚号、输出速度、输入输出模式。
      


      对于初始化，官方库有个更详尽复杂的函数能替代这两个函数的功能（官方函数课上已讲解）：

       ->



      引入官方初始化函数并申明。
      如何给初始化结构体赋值呢？
      先定义新的GPIO_InitTypeDef初始化结构体类型，然后用“.”访问结构体中的元素。输入输出模式、速度用枚举变量里取的别名。
      赋值完成以后将结构体的地址作为参数传入官方初始化函数。

      


      将灯闪烁功能整合成一个函数后：
      


      为了更好的程序可移植性多增加了一些宏定义：
      


      整合以后的代码：
stm32f10x_gpio.c：

1. #include "stm32f10x_gpio.h"
   
2. 
   
3. void RCC_Enable(RCC_TypeDef *RCCx,uint16_t IOPortx)
   
4. {
   
5.     RCCx->APB2ENR |=IOPortx;
   
6. }
   
7. void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin)
   
8. {
   
9.     GPIOx->BSRR |= GPIO_Pin;
   
10. }
    
11. 
    
12. void GPIO_ResetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin)
    
13. {
    
14.     GPIOx->BRR |= GPIO_Pin;
    
15. }
    
16. 
    
17. 
    
18. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
    
19. {
    
20.     uint32_t currentmode = 0x00, currentpin = 0x00, pinpos = 0x00, pos = 0x00;
    
21.     uint32_t tmpreg = 0x00, pinmask = 0x00;
    
22. 
    
23.     /*---------------------- GPIO 模式配置 --------------------------*/
    
24.     // 把输入参数GPIO_Mode的低四位暂存在currentmode
    
25.     currentmode = ((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x0F);
    
26. 
    
27.     // bit4是1表示输出，bit4是0则是输入
    
28.     // 判断bit4是1还是0，即首选判断是输入还是输出模式
    
29.     if ((((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x10)) != 0x00)
    
30.     {
    
31.         // 输出模式则要设置输出速度
    
32.         currentmode |= (uint32_t)GPIO_InitStruct->GPIO_Speed;
    
33.     }
    
34.     /*-------------GPIO CRL 寄存器配置 CRL寄存器控制着低8位IO- -------*/
    
35.     // 配置端口低8位，即Pin0~Pin7
    
36.     if (((uint32_t)GPIO_InitStruct->GPIO_Pin & ((uint32_t)0x00FF)) != 0x00)
    
37.     {
    
38.         // 先备份CRL寄存器的值
    
39.         tmpreg = GPIOx->CRL;
    
40. 
    
41.         // 循环，从Pin0开始配对，找出具体的Pin
    
42.         for (pinpos = 0x00; pinpos < 0x08; pinpos++)
    
43.         {
    
44.             // pos的值为1左移pinpos位
    
45.             pos = ((uint32_t)0x01) << pinpos;
    
46. 
    
47.             // 令pos与输入参数GPIO_PIN作位与运算，为下面的判断作准备
    
48.             currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;
    
49. 
    
50.             //若currentpin=pos,则找到使用的引脚
    
51.             if (currentpin == pos)
    
52.             {
    
53.                 // pinpos的值左移两位（乘以4），因为寄存器中4个寄存器位配置一个引脚
    
54.                 pos = pinpos << 2;
    
55.                 //把控制这个引脚的4个寄存器位清零，其它寄存器位不变
    
56.                 pinmask = ((uint32_t)0x0F) << pos;
    
57.                 tmpreg &= ~pinmask;
    
58. 
    
59.                 // 向寄存器写入将要配置的引脚的模式
    
60.                 tmpreg |= (currentmode << pos);
    
61. 
    
62.                 // 判断是否为下拉输入模式
    
63.                 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
    
64.                 {
    
65.                     // 下拉输入模式，引脚默认置0，对BRR寄存器写1可对引脚置0
    
66.                     GPIOx->BRR = (((uint32_t)0x01) << pinpos);
    
67.                 }
    
68.                 else
    
69.                 {
    
70.                     // 判断是否为上拉输入模式
    
71.                     if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
    
72.                     {
    
73.                         // 上拉输入模式，引脚默认值为1，对BSRR寄存器写1可对引脚置1
    
74.                         GPIOx->BSRR = (((uint32_t)0x01) << pinpos);
    
75.                     }
    
76.                 }
    
77.             }
    
78.         }
    
79.         // 把前面处理后的暂存值写入到CRL寄存器之中
    
80.         GPIOx->CRL = tmpreg;
    
81.     }
    
82.     /*-------------GPIO CRH 寄存器配置 CRH寄存器控制着高8位IO- -----------*/
    
83.     // 配置端口高8位，即Pin8~Pin15
    
84.     if (GPIO_InitStruct->GPIO_Pin > 0x00FF)
    
85.     {
    
86.         // // 先备份CRH寄存器的值
    
87.         tmpreg = GPIOx->CRH;
    
88. 
    
89.         // 循环，从Pin8开始配对，找出具体的Pin
    
90.         for (pinpos = 0x00; pinpos < 0x08; pinpos++)
    
91.         {
    
92.             pos = (((uint32_t)0x01) << (pinpos + 0x08));
    
93. 
    
94.             // pos与输入参数GPIO_PIN作位与运算
    
95.             currentpin = ((GPIO_InitStruct->GPIO_Pin) & pos);
    
96. 
    
97.             //若currentpin=pos,则找到使用的引脚
    
98.             if (currentpin == pos)
    
99.             {
    
100.                 //pinpos的值左移两位（乘以4），因为寄存器中4个寄存器位配置一个引脚
     
101.                 pos = pinpos << 2;
     
102. 
     
103.                 //把控制这个引脚的4个寄存器位清零，其它寄存器位不变
     
104.                 pinmask = ((uint32_t)0x0F) << pos;
     
105.                 tmpreg &= ~pinmask;
     
106. 
     
107.                 // 向寄存器写入将要配置的引脚的模式
     
108.                 tmpreg |= (currentmode << pos);
     
109. 
     
110.                 // 判断是否为下拉输入模式
     
111.                 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
     
112.                 {
     
113.                     // 下拉输入模式，引脚默认置0，对BRR寄存器写1可对引脚置0
     
114.                     GPIOx->BRR = (((uint32_t)0x01) << (pinpos + 0x08));
     
115.                 }
     
116.                 // 判断是否为上拉输入模式
     
117.                 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
     
118.                 {
     
119.                     // 上拉输入模式，引脚默认值为1，对BSRR寄存器写1可对引脚置1
     
120.                     GPIOx->BSRR = (((uint32_t)0x01) << (pinpos + 0x08));
     
121.                 }
     
122.             }
     
123.         }
     
124.         // 把前面处理后的暂存值写入到CRH寄存器之中
     
125.         GPIOx->CRH = tmpreg;
     
126.     }
     
127. }
     

复制代码

stm32f10x_gpio.h：

1. #ifndef __STM32F10X_GPIO_H
   
2. #define __STM32F10X_GPIO_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   
6. #define IOPortA ((uint16_t)0x0004) //GPIOA
   
7. #define IOPortB ((uint16_t)0x0008) //GPIOB
   
8. #define IOPortC ((uint16_t)0x0010) //GPIOC
   
9. #define IOPortD ((uint16_t)0x0020) //GPIOD
   
10. #define IOPortE ((uint16_t)0x0040) //GPIOE
    
11. #define IOPortF ((uint16_t)0x0080) //GPIOF
    
12. #define IOPortG ((uint16_t)0x0100) //GPIOG
    
13. 
    
14. #define GPIO_Pin0   ((uint16_t)0x0001) //选择Pin0
    
15. #define GPIO_Pin1   ((uint16_t)0x0002) //选择Pin1
    
16. #define GPIO_Pin2   ((uint16_t)0x0004) //选择Pin2
    
17. #define GPIO_Pin3   ((uint16_t)0x0008) //选择Pin3
    
18. #define GPIO_Pin4   ((uint16_t)0x0010) //选择Pin4
    
19. #define GPIO_Pin5   ((uint16_t)0x0020) //选择Pin5
    
20. #define GPIO_Pin6   ((uint16_t)0x0040) //选择Pin6
    
21. #define GPIO_Pin7   ((uint16_t)0x0080) //选择Pin7
    
22. 
    
23. #define GPIO_Pin8   ((uint16_t)0x0100) //选择Pin8
    
24. #define GPIO_Pin9   ((uint16_t)0x0200) //选择Pin9
    
25. #define GPIO_Pin10  ((uint16_t)0x0400) //选择Pin10
    
26. #define GPIO_Pin11  ((uint16_t)0x0800) //选择Pin11
    
27. #define GPIO_Pin12  ((uint16_t)0x1000) //选择Pin12
    
28. #define GPIO_Pin13  ((uint16_t)0x2000) //选择Pin13
    
29. #define GPIO_Pin14  ((uint16_t)0x4000) //选择Pin14
    
30. #define GPIO_Pin15  ((uint16_t)0x8000) //选择Pin15
    
31. #define GPIO_PinAll ((uint16_t)0xFFFF) //选择全部Pin
    
32. 
    
33. typedef enum
    
34. {
    
35.     GPIO_Speed_10MHz = 1,//10mhz 01
    
36.     GPIO_Speed_2MHz,     //2mhz 10
    
37.     GPIO_Speed_50MHz     //50mhz 11
    
38. } GPIO_SpeedTypeDef;
    
39. 
    
40. typedef enum
    
41. {
    
42.     GPIO_Mode_AIN = 0x00,            //模拟输入 0000 0000
    
43.     GPIO_Mode_In_FLOATING = 0x04,    //浮空输入 0000 0100
    
44.     GPIO_Mode_IPD = 0x28,            //下拉输入 0010 1000
    
45.     GPIO_Mode_IPU = 0x48,            //上拉输入 0100 1000
    
46. 
    
47.     GPIO_Mode_Out_OD = 0x14,         //开漏输出     0001 0100
    
48.     GPIO_Mode_Out_PP = 0x10,         //推挽输出     0001 0000
    
49.     GPIO_Mode_AF_OD = 0x1C,          //复用开漏输出 0001 1100
    
50.     GPIO_Mode_AF_PP = 0x18           //复用推挽输出 0001 1000
    
51. } GPIO_ModeTypeDef;
    
52. 
    
53. typedef struct
    
54. {
    
55.     uint16_t GPIO_Pin;
    
56.     GPIO_SpeedTypeDef GPIO_Speed;
    
57.     GPIO_ModeTypeDef GPIO_Mode;
    
58. } GPIO_InitTypeDef;
    
59. 
    
60. void RCC_Enable(RCC_TypeDef *RCCx,uint16_t IOPortx);
    
61. void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin);
    
62. void GPIO_ResetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin);
    
63. 
    
64. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);
    
65. 
    
66. #endif /*__STM32F10X_GPIO_H*/
    

复制代码

stm32f10x.h：

1. #ifndef __STM32F10X_H
   
2. #define __STM32F10X_H
   
3. 
   
4. //用来存放STM32寄存器映射的代码
   
5. //外设 peripheral
   
6. 
   
7. #define PERIPH_BASE        ((unsigned int)0x40000000)
   
8. #define APB2PERIPH_BASE    (PERIPH_BASE + 0x10000)
   
9. #define AHBPERIPH_BASE     (PERIPH_BASE + 0x20000)
   
10. 
    
11. #define RCC_BASE           (AHBPERIPH_BASE+0x1000)
    
12. #define GPIOB_BASE          (APB2PERIPH_BASE+0x0C00)
    
13. 
    
14. #define RCC_APB2ENR        *(unsigned int*)(RCC_BASE + 0x18)
    
15. 
    
16. #define GPIOB_CRL           *(unsigned int*)(GPIOB_BASE + 0x00)
    
17. #define GPIOB_CRH           *(unsigned int*)(GPIOB_BASE + 0x04)
    
18. #define GPIOB_IDR           *(unsigned int*)(GPIOB_BASE + 0x08)
    
19. #define GPIOB_ODR           *(unsigned int*)(GPIOB_BASE + 0x0C)
    
20. #define GPIOB_BSRR          *(unsigned int*)(GPIOB_BASE + 0x10)
    
21. #define GPIOB_BRR           *(unsigned int*)(GPIOB_BASE + 0x14)
    
22. #define GPIOB_LCKR          *(unsigned int*)(GPIOB_BASE + 0x18)
    
23. 
    
24. typedef unsigned int   uint32_t;
    
25. typedef unsigned short uint16_t;
    
26. 
    
27. typedef struct
    
28. {
    
29.     uint32_t CR;
    
30.     uint32_t CFGR;
    
31.     uint32_t CIR;
    
32.     uint32_t APB2RSTR;
    
33.     uint32_t APB1RSTR;
    
34.     uint32_t AHBENR;
    
35.     uint32_t APB2ENR;
    
36.     uint32_t APB1ENR;
    
37.     uint32_t BDCR;
    
38.     uint32_t CSR;
    
39. } RCC_TypeDef;
    
40. 
    
41. #define RCC ((RCC_TypeDef*)RCC_BASE)
    
42. 
    
43. typedef struct
    
44. {
    
45.     uint32_t CRL;
    
46.     uint32_t CRH;
    
47.     uint32_t IDR;
    
48.     uint32_t ODR;
    
49.     uint32_t BSRR;
    
50.     uint32_t BRR;
    
51.     uint32_t LCKR;
    
52. } GPIO_TypeDef;
    
53. 
    
54. #define GPIOB ((GPIO_TypeDef*)GPIOB_BASE)
    
55. 
    
56. #endif /*__STM32F10X_H*/
    

复制代码

      红灯闪烁：
main.c：

1. #include "stm32f10x.h"
   
2. #include "stm32f10x_gpio.h"
   
3. 
   
4. #define Red GPIO_Pin5
   
5. #define Green GPIO_Pin0
   
6. #define Blue GPIO_Pin1
   
7. 
   
8. #define LED_GPIO_PORT     GPIOB
   
9. 
   
10. void delay_us(int delay_us);
    
11. void delay_ms(int delay_ms);
    
12. void LedBlink(GPIO_TypeDef* PORT,int PIN);
    
13. 
    
14. int main(void)
    
15. {
    
16.     RCC_Enable(RCC,IOPortB);
    
17.     while(1)
    
18.     {
    
19.         LedBlink(LED_GPIO_PORT,Red);
    
20.     }
    
21. }
    
22. 
    
23. //函数体为空，目的是为了骗过编译器不报错
    
24. void SystemInit(void)
    
25. {}
    
26. 
    
27. //微秒级的延时
    
28. void delay_us(int delay_us)
    
29. {
    
30.     volatile unsigned int num;
    
31.     volatile unsigned int t;
    
32. 
    
33.     for (num = 0; num < delay_us; num++)
    
34.     {
    
35.         t = 11;
    
36.         while (t != 0)
    
37.         {
    
38.             t--;
    
39.         }
    
40.     }
    
41. }
    
42. //毫秒级的延时
    
43. void delay_ms(int delay_ms)
    
44. {
    
45.     volatile unsigned int num;
    
46.     for (num = 0; num < delay_ms; num++)
    
47.     {
    
48.         delay_us(1000);
    
49.     }
    
50. }
    
51. 
    
52. void LedBlink(GPIO_TypeDef* PORT,int PIN)
    
53. {
    
54.     GPIO_InitTypeDef GPIO_InitStructure;
    
55.     GPIO_InitStructure.GPIO_Pin = PIN;
    
56.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
57.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    
58.     GPIO_Init(PORT, &GPIO_InitStructure);
    
59. 
    
60.     GPIO_ResetBits(PORT,PIN);
    
61.     delay_ms(100);
    
62.     GPIO_SetBits(LED_GPIO_PORT,PIN);
    
63.     delay_ms(100);
    
64. }
    

复制代码

      红蓝交替：
main.c：

1. #include "stm32f10x.h"
   
2. #include "stm32f10x_gpio.h"
   
3. 
   
4. #define Red GPIO_Pin5
   
5. #define Green GPIO_Pin0
   
6. #define Blue GPIO_Pin1
   
7. 
   
8. #define LED_GPIO_PORT     GPIOB
   
9. 
   
10. void delay_us(int delay_us);
    
11. void delay_ms(int delay_ms);
    
12. void LedBlink(GPIO_TypeDef* PORT,int PIN);
    
13. 
    
14. int main(void)
    
15. {
    
16.     RCC_Enable(RCC,IOPortB);
    
17.     while(1)
    
18.     {
    
19.         LedBlink(LED_GPIO_PORT,Red);
    
20.         LedBlink(LED_GPIO_PORT,Blue);
    
21.     }
    
22. }
    
23. 
    
24. //函数体为空，目的是为了骗过编译器不报错
    
25. void SystemInit(void)
    
26. {}
    
27. 
    
28. //微秒级的延时
    
29. void delay_us(int delay_us)
    
30. {
    
31.     volatile unsigned int num;
    
32.     volatile unsigned int t;
    
33. 
    
34.     for (num = 0; num < delay_us; num++)
    
35.     {
    
36.         t = 11;
    
37.         while (t != 0)
    
38.         {
    
39.             t--;
    
40.         }
    
41.     }
    
42. }
    
43. //毫秒级的延时
    
44. void delay_ms(int delay_ms)
    
45. {
    
46.     volatile unsigned int num;
    
47.     for (num = 0; num < delay_ms; num++)
    
48.     {
    
49.         delay_us(1000);
    
50.     }
    
51. }
    
52. 
    
53. void LedBlink(GPIO_TypeDef* PORT,int PIN)
    
54. {
    
55.     GPIO_InitTypeDef GPIO_InitStructure;
    
56.     GPIO_InitStructure.GPIO_Pin = PIN;
    
57.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
58.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    
59.     GPIO_Init(PORT, &GPIO_InitStructure);
    
60. 
    
61.     GPIO_ResetBits(PORT,PIN);
    
62.     delay_ms(100);
    
63.     GPIO_SetBits(LED_GPIO_PORT,PIN);
    
64.     //delay_ms(100);
    
65. }
    

复制代码

lrz

可以可以，很详细