关键词：
创建自己的函数库
- 前言
- 一、什么是STM32标准函数库
- 1.定义：
- 2.作用：
- 3.对比：
- 二、构建库函数
- 1.修改寄存器地址封装
- 2.定义访问的结构体指针和引脚
- 3.创建封装函数
- 3.1创建拉低引脚函数
- 3.2创建引脚初始化函数
- 总结
前言
回顾一下，前面点亮led灯我们都进行了哪些操作。
首先需要看电路图，然后找到led灯的控制引脚，然后了解了控制引脚的方法是通过操作相应的物理地址，接着知道了可以映射物理地址也就是寄存器，通过寄存器来去配置，最后我们通过去查找芯片手册，了解各个寄存器的功能，对需要的寄存器进行配置，实现点亮led灯的功能。
到这里，我们成功将一大串的地址转化成可读性更好的寄存器，但是寄存器的操作相对于大部分人来说仍然是太复杂，大部分人只需要点亮灯，并不想知道它需要用到哪些寄存器，更不想去进行复杂的位操作，大家更希望能将寄存器的这些功能再一次进行封装打包，最好是进行一些简单的传参就可以将这个引脚配置好，所以库函数诞生了。库函数的作用，就是将寄存器根据其功能封装成一个个更加易于调用的函数接口，从而使代码的开发效率更高，可读性更好，更加易于维护。
一、什么是STM32标准函数库
1.定义：
他是ST公司针对stm32设计的一系列函数接口，即API（Application Program Interface）。
2.作用：
让开发者可调用这些函数接口来配置 STM32的寄存器，使开发人员得以脱离最底层的寄存器操作。
3.对比：
直接代码对比，第一个main函数和第二个main函数所实现的功能是一样的，但是第一个无论是否是开发者本人，都能很清楚明白的看明白代码在干嘛。而第二个main函数，只怕是开发者本人，时间长了也要回头挨条去查一下自己配置这些是在干嘛，一对比，高下立现。
int main(void)
led_init();
LED_RED=ON;
while(1);
int main(void)
RCC_AHB1ENR |= (1<<7);
GPIOH_MODER &= ~( 0x03<< (2*10));
GPIOH_MODER |= (1<<2*10);
GPIOH_OTYPER &= ~(1<<1*10);
GPIOH_OTYPER |= (0<<1*10);
GPIOH_OSPEEDR &= ~(0x03<<2*10);
GPIOH_OSPEEDR |= (0<<2*10);
GPIOH_PUPDR &= ~(0x03<<2*10);
GPIOH_PUPDR |= (1<<2*10);
GPIOH_BSRR |= (1<<16<<10);
while(1);
到这里，想说的话已经基本说完，后面的构建自己函数库，是否能搞懂其实并不重要，你只需要会用官方固件库即可。对于新手来说，我觉得一定要注意的是：所有的一切是围绕着目标去展开。 无论是地址，还是寄存器，亦或是库函数，都只是我们控制单片机的手段，能把这些全搞懂，很好很牛；只懂库函数操作去完成目标，也很好很牛。
二、构建库函数
1.修改寄存器地址封装
首先我们要知道，寄存器地址是基于物理地址的偏移地址，他们是连续的，和结构体的成员变量关系类似，所以我们可以通过结构体的形势来进行封装，将寄存器映射为结构体变量，再通过结构体变量，宏定义等方式来实现可读性的提升。
代码如下（示例）：
1 //volatile 表示易变的变量，防止编译器优化
2 #define __IO volatile
3 typedef unsigned int uint32_t;
4 typedef unsigned short uint16_t;
5
6 /* GPIO 寄存器列表 */
7 typedef struct
8 __IO uint32_t MODER; /*GPIO 模式寄存器 地址偏移: 0x00 */
9 __IO uint32_t OTYPER; /*GPIO 输出类型寄存器 地址偏移: 0x04 */
10 __IO uint32_t OSPEEDR; /*GPIO 输出速度寄存器 地址偏移: 0x08 */
11 __IO uint32_t PUPDR; /*GPIO 上拉/下拉寄存器 地址偏移: 0x0C */
12 __IO uint32_t IDR; /*GPIO 输入数据寄存器 地址偏移: 0x10 */
13 __IO uint32_t ODR; /*GPIO 输出数据寄存器 地址偏移: 0x14 */
14 __IO uint16_t BSRRL; /*GPIO 置位/复位寄存器低 16 位部分 地址偏移: 0x18 */
15 __IO uint16_t BSRRH; /*GPIO 置位/复位寄存器 高 16 位部分地址偏移: 0x1A */
16 __IO uint32_t LCKR; /*GPIO 配置锁定寄存器 地址偏移: 0x1C */
17 __IO uint32_t AFR[2]; /*GPIO 复用功能配置寄存器 地址偏移: 0x20-0x24 */
18 GPIO_TypeDef;
19
20 /*RCC 寄存器列表*/
21 typedef struct
22 __IO uint32_t CR; /*!< RCC 时钟控制寄存器,地址偏移: 0x00 */
23 __IO uint32_t PLLCFGR; /*!< RCC PLL 配置寄存器,地址偏移: 0x04 */
24 __IO uint32_t CFGR; /*!< RCC 时钟配置寄存器,地址偏移: 0x08 */
25 __IO uint32_t CIR; /*!< RCC 时钟中断寄存器,地址偏移: 0x0C */
26 __IO uint32_t AHB1RSTR; /*!< RCC AHB1 外设复位寄存器,地址偏移: 0x10 */
27 __IO uint32_t AHB2RSTR; /*!< RCC AHB2 外设复位寄存器,地址偏移: 0x14 */
28 __IO uint32_t AHB3RSTR; /*!< RCC AHB3 外设复位寄存器,地址偏移: 0x18 */
29 __IO uint32_t RESERVED0; /*!< 保留, 地址偏移：0x1C */
30 __IO uint32_t APB1RSTR; /*!< RCC APB1 外设复位寄存器,地址偏移: 0x20 */
31 __IO uint32_t APB2RSTR; /*!< RCC APB2 外设复位寄存器,地址偏移: 0x24*/
32 __IO uint32_t RESERVED1[2]; /*!< 保留,地址偏移：0x28-0x2C*/
33 __IO uint32_t AHB1ENR; /*!< RCC AHB1 外设时钟寄存器,地址偏移: 0x30 */
34 __IO uint32_t AHB2ENR; /*!< RCC AHB2 外设时钟寄存器,地址偏移: 0x34 */
35 __IO uint32_t AHB3ENR; /*!< RCC AHB3 外设时钟寄存器,地址偏移: 0x38 */
36 /*RCC 后面还有很多寄存器，此处省略*/
37 RCC_TypeDef;
简单分析一下代码，前面几行将volatile，unsigned int，unsigned short这几种关键字进行了宏定义，接着用这些宏定义后的关键字创建了一个名字为GPIO_TypeDef结构体和一个名字为RCC_TypeDef的结构体。
看到这，先提出几个问题，为什么不直接用C语言所支持的关键字而将其进行宏定义后，再用宏定义配置？后面创建的结构体所依据的是什么，成员变量定义的依据是什么？
先说第一个，我认为是方便移植更新，c语言中的关键字在其它语言中可能并不能生效，这样做的好处是，如果volatile，int这些类型在别的平台是叫别的名字，那么只需要将这个地方一替换那么整个代码都将会替换掉，这样可以很好地移植或者更新。相反如果你直接用的是关键字，那么则要将所有用到这个关键字的地方全部替换掉。从这里我们应该学到一个很重要的经验，对于一些高频用到的又可能有改动的变量，关键字等等，用宏定义去定义一下再去使用，可以在你修改代码时十分方便。
第二个结构体的创建所依据的是芯片手册，而变量的名字，排序及其大小都是按照芯片手册中寄存器的名字，排序，及其大小去设计的。
2.定义访问的结构体指针和引脚
代码如下（示例）：
1 /*定义 GPIOA-H 寄存器结构体指针*/
2 #define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
3 #define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
4 #define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
5 #define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
6 #define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
7 #define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
8 #define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
9 #define GPIOH ((GPIO_TypeDef *) GPIOH_BASE)
10
11 /*定义 RCC 外设 寄存器结构体指针*/
12 #define RCC ((RCC_TypeDef *) RCC_BASE)
1 /*GPIO 引脚号定义*/
2 #define GPIO_Pin_0 (uint16_t)0x0001) /*!< 选择 Pin0 (1<<0) */
3 #define GPIO_Pin_1 ((uint16_t)0x0002) /*!< 选择 Pin1 (1<<1)*/
4 #define GPIO_Pin_2 ((uint16_t)0x0004) /*!< 选择 Pin2 (1<<2)*/
5 #define GPIO_Pin_3 ((uint16_t)0x0008) /*!< 选择 Pin3 (1<<3)*/
6 #define GPIO_Pin_4 ((uint16_t)0x0010) /*!< 选择 Pin4 */
7 #define GPIO_Pin_5 ((uint16_t)0x0020) /*!< 选择 Pin5 */
8 #define GPIO_Pin_6 ((uint16_t)0x0040) /*!< 选择 Pin6 */
9 #define GPIO_Pin_7 ((uint16_t)0x0080) /*!< 选择 Pin7 */
10 #define GPIO_Pin_8 ((uint16_t)0x0100) /*!< 选择 Pin8 */
11 #define GPIO_Pin_9 ((uint16_t)0x0200) /*!< 选择 Pin9 */
12 #define GPIO_Pin_10 ((uint16_t)0x0400) /*!< 选择 Pin10 */
13 #define GPIO_Pin_11 ((uint16_t)0x0800) /*!< 选择 Pin11 */
14 #define GPIO_Pin_12 ((uint16_t)0x1000) /*!< 选择 Pin12 */
15 #define GPIO_Pin_13 ((uint16_t)0x2000) /*!< 选择 Pin13 */
16 #define GPIO_Pin_14 ((uint16_t)0x4000) /*!< 选择 Pin14 */
17 #define GPIO_Pin_15 ((uint16_t)0x8000) /*!< 选择 Pin15 */
18 #define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< 选择全部引脚 */
有了这两组定义，接下来就可以写封装函数了。
3.创建封装函数
3.1创建拉低引脚函数
代码如下（示例）：
void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
GPIOx->BSRRH = GPIO_Pin;
创建的函数有两个传参，一个是GPIO类型，一个是引脚号。也就是说我们想将某一个引脚拉低，只需要调用这个函数，将对应引脚的类型和引脚号填写上即可。比如我们之前控制PH10引脚。
代码如下（示例）：
GPIO_ResetBits(GPIOH,GPIO_Pin_10);
3.2创建引脚初始化函数
接下来创建一个复杂一点的端口初始化函数，首先根据上一篇我们知道了要配置一个端口，需要对引脚号、工作模式、输出速率、输出类型以及上/下拉模式这些进行配置。那么我们就以此创建结构体。
代码如下：
1 typedef uint8_t unsigned char;
2 /**
3 * GPIO 初始化结构体类型定义
4 */
5 typedef struct
6 uint32_t GPIO_Pin; /*!< 选择要配置的 GPIO 引脚
7 可输入 GPIO_Pin_ 定义的宏 */
8
9 uint8_t GPIO_Mode; /*!< 选择 GPIO 引脚的工作模式
10 可输入二进制值： 00 、01、 10、 11
11 表示输入/输出/复用/模拟 */
12
13 uint8_t GPIO_Speed; /*!< 选择 GPIO 引脚的速率
14 可输入二进制值： 00 、01、 10、 11
15 表示 2/25/50/100MHz */
16
17 uint8_t GPIO_OType; /*!< 选择 GPIO 引脚输出类型
18 可输入二进制值： 0 、1
19 表示推挽/开漏 */
20
21 uint8_t GPIO_PuPd; /*!<选择 GPIO 引脚的上/下拉模式
22 可输入二进制值： 00 、01、 10
23 表示浮空/上拉/下拉*/
24 GPIO_InitTypeDef;
如果这样配置的话，那么每个变量赋值仍然是要进行位操作赋值，依旧很不好识别，所以我们可以通过创建枚举来解决这个问题。
代码如下：
typedef enum
5 GPIO_Mode_IN = 0x00, /*!< 输入模式 */
6 GPIO_Mode_OUT = 0x01, /*!< 输出模式 */
7 GPIO_Mode_AF = 0x02, /*!< 复用模式 */
8 GPIO_Mode_AN = 0x03 /*!< 模拟模式 */
9 GPIOMode_TypeDef;
10
11 /**
12 * GPIO 输出类型枚举定义
13 */
14 typedef enum
15 GPIO_OType_PP = 0x00, /*!< 推挽模式 */
16 GPIO_OType_OD = 0x01 /*!< 开漏模式 */
17 GPIOOType_TypeDef;
18
19 /**
20 * GPIO 输出速率枚举定义
21 */
22 typedef enum
23 GPIO_Speed_2MHz = 0x00, /*!< 2MHz */
24 GPIO_Speed_25MHz = 0x01, /*!< 25MHz */
25 GPIO_Speed_50MHz = 0x02, /*!< 50MHz */
26 GPIO_Speed_100MHz = 0x03 /*!<100MHz */
27 GPIOSpeed_TypeDef;
28
29 /**
30 *GPIO 上/下拉配置枚举定义
31 */
32 typedef enum
33 GPIO_PuPd_NOPULL = 0x00,/*浮空*/
34 GPIO_PuPd_UP = 0x01, /*上拉*/
35 GPIO_PuPd_DOWN = 0x02 /*下拉*/
36 GPIOPuPd_TypeDef;
然后通过这些枚举去定义开始的结构体成员。
代码如下：
typedef struct
5 uint32_t GPIO_Pin; /*!< 选择要配置的 GPIO 引脚
6 可输入 GPIO_Pin_ 定义的宏 */
7
8 GPIOMode_TypeDef GPIO_Mode; /*!< 选择 GPIO 引脚的工作模式
9 可输入 GPIOMode_TypeDef 定义的枚举值*/
10
11 GPIOSpeed_TypeDef GPIO_Speed; /*!< 选择 GPIO 引脚的速率
12 可输入 GPIOSpeed_TypeDef 定义的枚举值 */
13
14 GPIOOType_TypeDef GPIO_OType; /*!< 选择 GPIO 引脚输出类型
15 可输入 GPIOOType_TypeDef 定义的枚举值*/
16
17 GPIOPuPd_TypeDef GPIO_PuPd; /*!<选择 GPIO 引脚的上/下拉模式
18 可输入 GPIOPuPd_TypeDef 定义的枚举值*/
19 GPIO_InitTypeDef;
这样，在我们配置时，只需要给变量附上对应的枚举值就好了。
代码如下：
1 GPIO_InitTypeDef InitStruct;
2
3 /* LED 端口初始化 */
4 /*选择要控制的 GPIO 引脚*/
5 InitStruct.GPIO_Pin = GPIO_Pin_10;
6 /*设置引脚模式为输出模式*/
7 InitStruct.GPIO_Mode = GPIO_Mode_OUT;
8 /*设置引脚的输出类型为推挽输出*/
9 InitStruct.GPIO_OType = GPIO_OType_PP;
10 /*设置引脚为上拉模式*/
11 InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
12 /*设置引脚速率为 2MHz */
13 InitStruct.GPIO_Speed = GPIO_Speed_2MHz;
这样，我们将InitStruct这个结构体的各个成员都赋上值了，接着就是创建一个函数，来处理这个结构体的值。
代码如下：
1
2 /**
3 *函数功能：初始化引脚模式
4 *参数说明：GPIOx，该参数为 GPIO_TypeDef 类型的指针，指向 GPIO 端口的地址
5 * GPIO_InitTypeDef:GPIO_InitTypeDef 结构体指针，指向初始化变量
6 */
7 void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
8
9 uint32_t pinpos = 0x00, pos = 0x00 , currentpin = 0x00;
10
11 /*-- GPIO Mode Configuration --*/
12 for (pinpos = 0x00; pinpos < 16; pinpos++)
13 /*以下运算是为了通过 GPIO_InitStruct->GPIO_Pin 算出引脚号 0-15*/
14
15 /*经过运算后 pos 的 pinpos 位为 1，其余为 0，与 GPIO_Pin_x 宏对应。
16 pinpos 变量每次循环加 1，*/
17 pos = ((uint32_t)0x01) << pinpos;
18
19 /* pos 与 GPIO_InitStruct->GPIO_Pin 做 & 运算，
20 若运算结果 currentpin == pos，
21 则表示 GPIO_InitStruct->GPIO_Pin 的 pinpos 位也为 1，
22 从而可知 pinpos 就是 GPIO_InitStruct->GPIO_Pin 对应的引脚号：0-15*/
23 currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;
24
25 /*currentpin == pos 时执行初始化*/
26 if (currentpin == pos)
27 /*GPIOx 端口，MODER 寄存器的 GPIO_InitStruct->GPIO_Pin 对应的引脚，
28 MODER 位清空*/
29 GPIOx->MODER &= ~(3 << (2 *pinpos));
30
31 /*GPIOx 端口，MODER 寄存器的 GPIO_Pin 引脚，
32 MODER 位设置"输入/输出/复用输出/模拟"模式*/
33 GPIOx->MODER |= (((uint32_t)GPIO_InitStruct->GPIO_Mode) << (2 *pinpos));
34
35 /*GPIOx 端口，PUPDR 寄存器的 GPIO_Pin 引脚，
36 PUPDR 位清空*/
37 GPIOx->PUPDR &= ~(3 << ((2 *pinpos)));
38
39 /*GPIOx 端口，PUPDR 寄存器的 GPIO_Pin 引脚，
40 PUPDR 位设置"上/下拉"模式*/
41 GPIOx->PUPDR |= (((uint32_t)GPIO_InitStruct->GPIO_PuPd) << (2 *pinpos));
42
43 /*若模式为"输出/复用输出"模式，则设置速度与输出类型*/
44 if ((GPIO_InitStruct->GPIO_Mode == GPIO_Mode_OUT) ||
45 (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_AF))
46 /*GPIOx 端口，OSPEEDR 寄存器的 GPIO_Pin 引脚，
47 OSPEEDR 位清空*/
48 GPIOx->OSPEEDR &= ~(3 << (2 *pinpos));
49 /*GPIOx 端口，OSPEEDR 寄存器的 GPIO_Pin 引脚，
50 OSPEEDR 位设置输出速度*/
51 GPIOx->OSPEEDR |= ((uint32_t)(GPIO_InitStruct->GPIO_Speed)<<(2 *pinpos));
52
53 /*GPIOx 端口，OTYPER 寄存器的 GPIO_Pin 引脚，
54 OTYPER 位清空*/
55 GPIOx->OTYPER &= ~(1 << (pinpos)) ;
56 /*GPIOx 端口，OTYPER 位寄存器的 GPIO_Pin 引脚，
57 OTYPER 位设置"推挽/开漏"输出类型*/
58 GPIOx->OTYPER |= (uint16_t)(( GPIO_InitStruct->GPIO_OType)<< (pinpos));
59
60
61
读一下这个函数，有两个传参，第一个是端口类型，也就是之前我们创建的那些GPIOx指针(x=A…H),第二个就是我们刚刚赋值的结构体，然后函数内部将结构体变量的值传给对应寄存器，最终控制电路板实现端口初始化。
我们要想实现拉低PH10引脚，只需要调用这两个函数便能实现。
代码如下：
12 int main(void)
13
14 GPIO_InitTypeDef InitStruct;
15
16 /*开启 GPIOH 时钟，使用外设时都要先开启它的时钟*/
17 RCC->AHB1ENR |= (1<<7);
18
19 /* LED 端口初始化 */
20
21 /*初始化 PH10 引脚*/
22 /*选择要控制的 GPIO 引脚*/
23 InitStruct.GPIO_Pin = GPIO_Pin_10;
24 /*设置引脚模式为输出模式*/
25 InitStruct.GPIO_Mode = GPIO_Mode_OUT;
26 /*设置引脚的输出类型为推挽输出*/
27 InitStruct.GPIO_OType = GPIO_OType_PP;
28 /*设置引脚为上拉模式*/
29 InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
30 /*设置引脚速率为 2MHz */
31 InitStruct.GPIO_Speed = GPIO_Speed_2MHz;
32 /*调用库函数，使用上面配置的 GPIO_InitStructure 初始化 GPIO*/
33 GPIO_Init(GPIOH, &InitStruct);
34
35 /*使引脚输出低电平,点亮 LED1*/
36 GPIO_ResetBits(GPIOH,GPIO_Pin_10);
51 while (1);
52
53
总结
这一篇主要篇幅比较长，主要想分享为什么要有库函数，以及库函数为什么要这么去写，这么写的好处是什么，在今后的应用中，我们很少需要自己去写库函数，标准库函数已经满足我们绝大部分的需求了，我们只需要去调用。不过相对于学习本身，我更希望分享如何去学习，这样才能举一反三，在这个科技与狠活快速更新的年代，始终跟的上脚步。
创建自己的函数库(代码片段)
创建自己的函数库前言一、什么是STM32标准函数库1.定义：2.作用：3.对比：二、构建库函数1.修改寄存器地址封装2.定义访问的结构体指针和引脚3.创建封装函数3.1创建拉低引脚函数3.2创建引脚初始化函数总结前言回顾... 查看详情
静态链接库与动态链接库的区别及动态库的创建（转）
一、引言通常情况下，对函数库的链接是放在编译时期（compiletime）完成的。所有相关的对象文件（objectfile）与牵涉到的函数库（library）被链接合成一个可执行文件（executablefile）。程序在运行时，与函数库再无瓜葛，因为所有... 查看详情
linux动态链接库.so文件的创建与使用
1.介绍 使用GNU的工具我们如何在Linux下创建自己的程序函数库?一个“程序函数库”简单的说就是一个文件包含了一些编译好的代码和数据，这些编译好的代码和数据可以在事后供其他的程序使用。程序函数库可以使... 查看详情
静态库的创建和使用，制作通用静态库(代码片段)
...源的包装，你可以将其打包并很容易的在项目之间共享。创建静态库 查看详情
pcb创建自己的原件库
创建如何创建创建原理图元器件库创建器件原理图创建器件PCB 如何创建器件PCB1自己画2修改现有3联合PCB和原理图1创建原理图元器件库 2创建器件原理图 从其他复制修改原理图 3... 查看详情
怎么给dev添加函数库
...d.h"，可以直接在头文件里定义。具体实现方法如下：创建源代码保存为.h在名字空间里写入自己的函数最后把该头文件放到dev-cpp的include目录里 代码如下：#ifndef_define#define_definenamespacehehe //名字空间hehe,可以随便设，... 查看详情
js库创建
建立js库模板1(function(){2function$(){3alert("被调用到喽！");4/*alert()是JavaScript脚本语言中窗口window对象的一个常用方法；5其主要用法就是在你自己定义了一定的函数以后，通过执行相应的操作，6所弹出对话框的语言。并且alert对话框... 查看详情
列出不同用户在他们自己的位置创建的所有 SVN 存储库
】列出不同用户在他们自己的位置创建的所有SVN存储库【英文标题】：ListoutallSVNreposcreatedbyvarioususersintheirownlocations【发布时间】：2011-02-1809:29:17【问题描述】：如何列出不同用户使用svnadmincreate创建的所有颠覆存储库？我想设置... 查看详情
自己做的类库封装socket类请问怎样实现非阻塞模式
当使用socket()函数和WSASocket()函数创建套接字时，默认都是阻塞的。在创建套接字之后，通过调用ioctlsocket()函数，将该套接字设置为非阻塞模式。//-------------------------//SetthesocketI/Omode:InthiscaseFIONBIO//enablesordisablestheblockingmodeforthe//s... 查看详情
如何在没有镜像的情况下创建本地自己的 pypi 存储库索引？
】如何在没有镜像的情况下创建本地自己的pypi存储库索引？【英文标题】：howtocreatelocalownpypirepositoryindexwithoutmirror?【发布时间】：2013-08-0519:25:15【问题描述】：我们有几个自己的python包，并希望使用简单的接口为它们创建本地p... 查看详情
C++：如何构建我自己的实用程序库？
...我不应该重新发明***，并且我可以将外部库用于我为自己创建的 查看详情
rf自定义库
...Library库名-相对路径按照其他库的关键字调用方式一样。创建测试库类/模块静态(Static)API最简单的办法是实现一个模块(用Python)，或者类(用Python或Java)，其中的方法(methods)直接映射为关键字名称。关键字接受和方法相同的参数。... 查看详情
创建函数-----------(函数递归创建库source命令)
6.5函数递归与创建库6.5.1函数递归 自给(self-containment)是局部函数变量的一个特性。自给函数除了脚本通过命令行传递的变量，不使用函数之外的任何资源。 ... 查看详情
keil中怎样制作自己的库函数
指点详细一点，最好列出具体的操作步骤写好你的代码在optionfortarget->output里面勾选createlibraty编译会在目录下生成.lib文件用的时候..在工程文件中载入lib文件.并且库函数申明一下即可参考技术A随便写几个函数,放在当前目录下... 查看详情
ubuntu下借助qtcreator创建属于自己的共享库
简介:在 Windows上，共享库由 .dll 表示；在Linux上，由 .so 表示。 SharedLibrary的优势共享库，又称动态库或so文件，顾名思义，它可以在可执行文件启动时加载或进程运行期被调用。使用共享库有很多好处，例... 查看详情
软件使用使用sothisai平台的公有库，创建适合自己项目的开发环境（私有库）(代码片段)
如何使用SothisAI平台的公有库，创建适合自己项目的开发环境（私有库）库：即是指Docker镜像，公有库即是创建人分享，而任何人都可以使用的库；私有库即是创建人不分享，自行使用的镜像资源。... 查看详情
创建自己的docker本地库(代码片段)
创建私有docker库服务器centos安装centos服务器，网上教程比较多，自己查找。安装宝塔自行到网站的查询mDNS为了不用在局域网中每一次查询IP地址，可以打开centos的mDNS功能。这样子我们在局域网内就可以直接用服务器... 查看详情
创建自己的docker本地库(代码片段)
创建私有docker库服务器centos安装centos服务器，网上教程比较多，自己查找。安装宝塔自行到网站的查询mDNS为了不用在局域网中每一次查询IP地址，可以打开centos的mDNS功能。这样子我们在局域网内就可以直接用服务器... 查看详情