从自定义的库函数到STM32官方标准库

迷南。 2022-04-10 14:18 167阅读 0赞

在[上一节][Link 1]的基础上，进一步改写代码，再引入官方标注库函数。虽然官方标准库慢慢式微，有一些别的库可能会取代它，但是并不妨碍我们继续拿官方库来写代码，吸取里边好的写法，强化下C语言技能，加深对寄存器的理解也是不错的。  
　　本文模仿库函数，首先自定义库函数，然后一步一步改写代码，最终引入官方标准库函数。

## 实现流水灯 ##

void delay(unsigned int a)
    { 
        while(a--);
    }
    
    int main(void)
    { 
        RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
        GPIOB->CRH &= ~(0xf<<(0*4)|0xf<<(1*4));
        GPIOB->CRH |= 0x3<<(0*4)|0x3<<(1*4);    
        while(1)
        {    
            GPIOB->ODR &= ~(1<<8);  //PB8 = 0
            GPIOB->ODR |= 1<<9;         //PB9 = 1
            delay(0xfffff);
            GPIOB->ODR &= ~(1<<9);   //PB9 = 0
            GPIOB->ODR |= 1<<8;      //PB8 = 1
            delay(0xfffff);
        }    
    }

主要是增加了延时函数与while(1)的循环。通过寄存器，实现流水灯。这是单片机最基础的实验，意义等同于helloworld。这些代码如果有51基础，是很好理解的。但是存在问题：代码的扩展性与维护性较差，存在较多的复制粘贴，不太容易看懂，如果出现业务变更，如LED的引脚换了，那么修改工作太大。  
  接下来我们来自己从零开始，写一个库函数，目的是提高代码的扩展性和可维护性，具体表现是：  
1方便移植，比较通用。  
2读起来没那么费劲，不用翻着手册来读。

## 自定义IO初始化函数 ##

在不考虑时钟的情况下，配置一个IO口（也就是引脚）需要知道以下信息：  
  1 PORT PA还是PB  
  2 PIN PB1还是PB2  
  3 模式 输入还是输出？  
  我们可以把这几个信息作为函数的参数，用一个函数来进行IO的初始化。例如初始化PB0位2Mhz的推挽输出：

void easy_IO(GPIO_TypeDef *GPIOx,char pin,char cny,char mode)
    { 
        uint8_t temp;
        if(mode != shuru)
        { 
            GPIOx->CRL &= ~(0xf << pin*4);
            temp =(cny<<2)|(mode);
            GPIOx ->CRL |= temp << (pin*4);
        }
    }
    easy_IO(GPIOB,0,tuiwan,MHZ2);//调用

用这种方法可以比较方便地进行引脚的初始化，弊端在于，参数太多，容易出错。有没有更好的传参数的方法？  
**使用结构体**  
  首先把需要的信息都放在一个结构体内。

typedef struct
    { 
        Uint16_t pin;
        uint8_t mode;//输入还是输出，速度
        uint8_t cny;//输出模式
    }GPIO_InitST;

然后定义两个枚举类型，为参数可能的取值起一个好理解的名字：

typedef enum
    { 
        shuru = 0x00,
        MHZ10,
        MHZ2,
        MHZ50,
    }ModeEm;
    typedef enum
    { 
        tuiwan = 0x00,
        kailou,
        futuiwan,
        fukailou,
    }CNYEm;

最后定义一个函数，用于IO的初始化：

//自定义IO初始化函数
    void myGPIO_Init(GPIO_TypeDef* GPIOx,GPIO_InitST* st)
    { 
        if(st->mode != shuru)//暂时先只处理输出的情况
        { 
            uint8_t temp;
            if(st->pin<8)//P0-P7用CRL
            { 
                GPIOx->CRL &= ~(0xf<<st->pin*4);
                temp = (st->cny<<2)|(st->mode);
                GPIOx->CRL |= temp<<st->pin*4;
            }
            else//P8及以上是CRH
            { 
                GPIOx->CRH &= ~(0xf<<(st->pin-8)*4);
                temp = (st->cny<<2)|(st->mode);
                GPIOx->CRH |= temp<<(st->pin-8)*4;              
            }
        }
    }

主函数中IO的初始化可以直接调用函数：

int main(void)
    { 
        GPIO_InitST myst;
        RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
            
        myst.pin = 8;
        myst.mode = MHZ50;
        myst.cny = tuiwan;
        myGPIO_Init(GPIOB,&myst);
    
        myst.pin = 9;
        myGPIO_Init(GPIOB,&myst);
        while(1)
        {    
            GPIOB->ODR &= ~(1<<8);  //PB8 = 0
            GPIOB->ODR |= 1<<9;         //PB9 = 1
            delay(0xfffff);
            GPIOB->ODR &= ~(1<<9);   //PB9 = 0
            GPIOB->ODR |= 1<<8;      //PB8 = 1
            delay(0xfffff);
        }    
    }

编译程序，下载观察现象，跟流水灯一样。

## 使用独热码操作多个引脚 ##

有两个不同引脚的话，需要调用两次初始化函数，能不能调用一次初始化的函数就初始化两个引脚？可以，代码仍然有改进的空间。  
  使用独热码one-hot code, 直观来说就是有多少个状态就有多少比特，而且只有一个比特为1，其他全为0的一种码制。  
  如果引脚0定义为0x01，引脚1定义为0x02，引脚2定义为0x04（而不是0x03），那么0x07就可以代表这三个引脚。想同时初始化三个引脚，只需要传入一个参数，0x07。

//自定义IO初始化函数
    void myGPIO_Init(GPIO_TypeDef* GPIOx,GPIO_InitST* st)
    { 
        uint16_t i=0, j = 0, pflg = 0;
        uint8_t temp;
        if(st->mode != shuru)//暂时先只处理输出的情况
        { 
            for(i = 0 ; i < 16 ; i++)
            { 
                j = 0x01 << i;
                pflg = st->pin & j;
                if (pflg == j)
                { 
                    if(i<8)//P0-P7用CRL
                    { 
                        GPIOx->CRL &= ~(0xf<<i*4);
                        temp = (st->cny<<2)|(st->mode);
                        GPIOx->CRL |= temp<<i*4;   
                    }
                    else//P8及以上是CRH
                    { 
                        GPIOx->CRH &= ~(0xf<<(i-8)*4);
                        temp = (st->cny<<2)|(st->mode);
                        GPIOx->CRH |= temp<<(i-8)*4;                
                    }
                }
            }
        }
    }

以上代码，主要思想是通过一个for循环，将传入的参数按位取出，并判断这一位是0还是1。如果是1，则需要对这一位对应的IO进行操作。  
  然后主函数的调用也需要做相应的修改，一次传入PB8与PB9两个引脚。

#define Pin_8 ((uint16_t)0x0100) /*!< Pin 8 selected */
    #define Pin_9 ((uint16_t)0x0200) /*!< Pin 9 selected */
    int main(void)
    { 
        GPIO_InitST myst;
        RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
            
        myst.pin = Pin_8| Pin_9;
        myst.mode = MHZ50;
        myst.cny = tuiwan;
        myGPIO_Init(GPIOB,&myst);
    
        while(1)
        {    
            GPIOB->ODR &= ~(1<<8);  //PB8 = 0
            GPIOB->ODR |= 1<<9;         //PB9 = 1
            delay(0xfffff);
            GPIOB->ODR &= ~(1<<9);   //PB9 = 0
            GPIOB->ODR |= 1<<8;      //PB8 = 1
            delay(0xfffff);
        }    
    }

## 改写引脚操作 ##

在使用ODR寄存器的时候，总是需要关注那些不应该被操作的引脚，怕误操作。现在由51单片机的思维改为STM32的思维。STM32提供了特别丰富，好用的寄存器，例如BSRR（端口位设置/清除）寄存器，对某个位写1代表把对应的IO设置为高电平，其它位写0，则不对其它位产生影响。  
  看数据手册  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dlZWtfbW9ua2V5_size_16_color_FFFFFF_t_70]  
  跟它类似的有个BRR寄存器，功能是端口位清零。  
  借助这两个寄存器，我们可以很方便的写出IO设置为1和IO设置为0的两个函数：

void mySetbits(GPIO_TypeDef* GPIOx,uint16_t pin)//引脚设置1
    { 
        GPIOx->BSRR = pin;
    }
    void myResetbits(GPIO_TypeDef* GPIOx, uint16_t pin)//引脚设置0
    { 
        GPIOx-> BRR= pin;
    }

然后修改主函数内的死循环：

while(1)
        {    
            myResetbits(GPIOB,Pin_8);  //PB8 = 0
            mySetbits(GPIOB,Pin_9);     //PB9 = 1
            delay(0xfffff);
            myResetbits(GPIOB,Pin_9);   //PB9 = 0
            mySetbits(GPIOB,Pin_8);      //PB8 = 1
            delay(0xfffff);
        }

最终效果还是一样的，但代码看上去就比较爽心悦目了。事实上，这已经很接近于库函数的代码了。

## 引入官方库函数 ##

官方的固件库提供了很多好用的函数，接下来由自定义的固件库转到官方标准固件库。  
  官方标准固件库（以后简称官方库）的函数可以查看文档《STM32固件库使用手册的中文翻译版.pdf》  
  官方库除了提供了详细的函数说明，还提供了使用的例子。另外，通过函数的跳转，可以看到官方库的源码，这些源码经过千锤百炼，都是学习单片机编程的好榜样。  
  与引脚相关的函数都在GPIO章节，读者可以自行查看。新建一个函数，IO\_Init()。参考例子，稍作修改就能写完LED引脚的初始化函数。

void IO_Init(void)
    { 
        GPIO_InitTypeDef GPIO_InitStructure;
         
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);   
      
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9; 
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
        GPIO_Init(GPIOB, &GPIO_InitStructure);
    }
    
    int main(void)
    { 
        IO_Init();
        GPIO_SetBits(GPIOB,GPIO_Pin_8|GPIO_Pin_9);
        while(1)
        {    
            GPIO_ResetBits(GPIOB,GPIO_Pin_8);  //PB8 = 0
            GPIO_SetBits(GPIOB,GPIO_Pin_9);     //PB9 = 1
            delay(0xfffff);
            GPIO_ResetBits(GPIOB,GPIO_Pin_9);   //PB9 = 0
            GPIO_SetBits(GPIOB,GPIO_Pin_8);      //PB8 = 1
            delay(0xfffff);
        }    
    }

我们通过对寄存器的封装，实现了最简单的库函数。使用STM32编程，库函数远比寄存器方便。所谓的库函数，就是封装寄存器，提供接口给用户调用。如果是需要快速开发的时候，可以直接使用库函数，不必纠结于是怎样实现的，要大胆的拿来就用。但是，学习的时候，还是要考虑下库函数的实现方式，库函数是经过千锤百炼的优秀代码。因此我们花费巨大的精力，自己实现了简单的库函数，就是为了让大家明白，库函数不神秘，如果需要，我们自己就能写出来。以后使用其它的平台，也能根据数据手册，操作寄存器，实现功能，并把代码封装，优化，这才是最好的结果。  
  项目式开发要避免重复造轮子，要尽快完成目标，而不是把时间浪费在不必要的细节上。库函数与寄存器两种开发方式并不对立，哪个方便用哪个即可。不同类型的库也是，那个方便用哪个即可。

[Link 1]: https://blog.csdn.net/geek_monkey/article/details/86293880
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dlZWtfbW9ua2V5_size_16_color_FFFFFF_t_70]: /images/20220328/1b2e8558e4534962b686219c4db4f208.png