【个人总结】1.开发基础工作三年的嵌入式常见知识点梳理及开发技术要点（欢迎指正、补充）

【个人总结】1. 开发基础 工作三年的嵌入式常见知识点梳理及开发技术要点（欢迎指正、补充）

工作快三年以来 分别进行了嵌入式MCU及外设开发、RTOS、传感器、文件系统及USB、Linux、GUI、通讯协议、毫米波雷达、少量的DSP和物联网开发。 特此总结

文章目录 C/C++基础main指针和大小端内存分配结构体、联合体、位段i++和++i虚函数C++的不同点命名空间在C++中运行Cclass类函数重载、函数模板 Makefilegit卡尔曼滤波递归算法数据融合数据预测 附录：Cortex-M架构的SysTick系统定时器精准延时和MCU位带操作SysTick系统定时器精准延时延时函数阻塞延时非阻塞延时 位带操作位带代码位带宏定义总线函数 一、位带操作理论及实践二、如何判断MCU的外设是否支持位带

C/C++基础 main

可以用void 也可以用int 传参可以不用（void） 也可以传三个参数 不过一般是两个

int main(int argc , char* argv[],char* envp[]);

对应参数个数、参数（字符串形式）列表 第三个指向环境变量表字符串

指针和大小端

对于指针 看懂：((void(*)())NULL)(); 即可 大小端则对应内存分配：

uint32_t dat=0; uint8_t buf[]={0x40,0x80,0x00,0x00}; memcpy(&dat,buf,4); float f=0.0f; swap32(&dat); //大小端转换 f=*((float*)&dat); //地址强转 printf("%f",f); 内存分配

堆、栈、数据段（全局、静态）、常量和代码段 栈就是函数内的临时变量 堆是靠用户分配的 全局可访问 如new和malloc 当然也要delete或者free 数据段存储静态变量和全局变量 常量和代码段则存储只读的数据 编译器编译后可以看到各个空间的利用率 如果是TI RTOS那种 则可以用堆空间来模拟线程中的栈 而不使用系统栈区 且内存分配可以由用户来定义

结构体、联合体、位段

除常见结构体外 还有联合体、位段

typedef struct { char c; int i; } MyStruct; typedef union { char c; int i; } MyUnion; struct packed_struct { unsigned int f1 :1; unsigned int f2 :1; unsigned int f3 :1; unsigned int type :4; unsigned int index :9; };

结构体内传入函数指针即可实现类似C++的函数调用

i++和++i #include <stdio.h> int main() { int i=1,a=0,b=0; a=i++; b=++i; printf("i=%d,a=%d,b=%d\n",i,a,b); return 0; }

得到：

3 1 3

原因是i++是先赋值在自增 ++i是先自增再赋值

虚函数

函数声明：__weak 或virtual表示虚函数 在MCU开发中 使用__weak 声明表示虚函数 重写时 只需要去掉__weak定义即可 如：

__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

在C++类声明中 virtual表示虚函数 重写时只能在继承其父类下声明的同名函数末尾加上override 然后再实现实例 譬如QThread下的run函数

virtual void run(); class Thread02 : public QRunnable { public: Thread02(); ~Thread02(); void run() override; }; C++的不同点 命名空间

用::表示namespace 使用using namespace声明可指定

using namespace std; int a=0; cin>>a; //输入到a cout<<a; //输出a 在C++中运行C

如果在C++中运行C 则需要：

extern "C" { ... }

一般可以宏定义：

#ifdef __cplusplus extern "C" { #endif ...//C文件的函数声明 #ifdef __cplusplus } #endif

导入C库则使用前面加个c的方式导入

#include <cstdio> class类

支持类class的定义方式 包括构造函数和解析函数

class A { public: int a; A(); ~A(); private: int b; } A::A() { ... } A::~A() { ... }

同时 类可以继承 以实现加入第二个类的属性

class B { int b; } class A: public B { int a; } 函数重载、函数模板

有编译器根据输入的参数变换不同的替换类型

int jf(int a,int b){ //1 return a-b; } double jf(int a,double b){ //2 return a-b; } double jf(double b,int a){ //3 return a-b; } int jf(int a,int b,double c){ //4 return a-b-c; } template<typename T1,typename T2> T1 add(T1 a,T2 b) { return a+b; } int main(){ int x=14,y=9,z=45; double m=9.45,n=7.22; cout<<"x-z="<<jf(x,z)<<endl; //1 cout<<"y-m="<<jf(y,m)<<endl; //2 cout<<"n-y="<<jf(n,y)<<endl ; //3 cout<<"x-y-z="<<jf(x,y,z)<<endl; //4 x=23;y=8; m=9.332;n=5.91; cout<<add(x,y)<<endl; cout<<add(m,x)<<endl; cout<<add(x,m)<<endl; cout<<add(n,m)<<endl; return 0; } Makefile

最简单的方式 编译、导入编译、删除

main: main.o input.o calcu.o gcc -o main main.o input.o calcu.o main.o: main.c gcc -c main.c input.o: input.c gcc -c input.c calcu.o: calcu.c gcc -c calcu.c clean: rm *.o rm main

使用自动化变量可以变成：

objects = main.o input.o calcu.o main: $(objects) gcc -o main $(objects) %.o : %.c gcc -c $< clean: rm *.o rm main

编译时 会自动加载Makefile文件

使用名称变量 如指定内核源码文件的编译：

KERNELDIR := /home/alientek/linux/atk-mp135/linux/my_linux/linux-5.15.24 CURRENT_PATH := $(shell pwd) obj-m := chrdevbase.o build: kernel_modules kernel_modules: $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules clean: $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean git

初始化 git init 首次使用还应添加邮箱、密钥

git config --global user.name "zhangsan" git config --global user.email "zhangsan@xxxx " ssh-keygen -t rsa -C "zhangsan@xxxx " //保存密钥

拉取项目 git clone 项目地址 拉取某个分支 git pull origin 分支名 查看当前分支 git branch 创建并切换分支 git checkout -b 分支名

提交代码： 先暂存 再本地提交 最后远程提交 暂存 git add

git add --all //添加所有修改的文件 更新整个仓库（删除的文件也会同步删除） git add . //根据.gitignore过滤 git add * //添加文件

本地提交 git commit -m "更新的内容说明" 远程提交 git push origin 分支名

卡尔曼滤波

递归算法

在测量同一数据时 存在误差 最简单的方法就是求算术平均值 引入递归的思想 卡尔曼增益与估计误差、测量误差的关系为： k越大 估计误差越小 结果趋近于上一次的估计值 数据收敛

数据融合

测量同一数据 有两种不同的测量方式 得出两种测量结果 且两者都有误差 满足正态分布 谁的方差越小 越相信谁的数据

数据预测

对于动态的数据 其数据一直在变化 存在系统误差（过程误差） 另外 有一个观测的测量结果 存在测量误差 通过递归思想 并将两者进行数据融合 得到五大公式： 通常用于一维数据随时间变化（过程）的滤波

附录：Cortex-M架构的SysTick系统定时器精准延时和MCU位带操作 SysTick系统定时器精准延时 延时函数

SysTick->LOAD中的值为计数值 计算方法为工作频率值/分频值 比如工作频率/1000 则周期为1ms

以ADuCM4050为例：

#include "ADuCM4050.h" void delay_ms(unsigned int ms) { SysTick->LOAD = 26000000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能52MHz的系统定时器 while(ms--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 26000000/1000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能52MHz的系统定时器 while(us--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }

其中的52000000表示芯片的系统定时器频率 32系列一般为外部定时器频率的两倍

Cortex-M架构SysTick系统定时器阻塞和非阻塞延时

阻塞延时

首先是最常用的阻塞延时

void delay_ms(unsigned int ms) { SysTick->LOAD = 50000000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while(ms--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 50000000/1000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while(us--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }

50000000表示工作频率 分频后即可得到不同的延时时间 以此类推

那么 不用两个嵌套while循环 也可以写成：

void delay_ms(unsigned int ms) { SysTick->LOAD = 50000000/1000*ms-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 50000000/1000/1000*us-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }

但是这种写法有个弊端 那就是输入ms后，最大定时不得超过计数值，也就是不能超过LOAD的最大值，否则溢出以后，则无法正常工作

而LOAD如果最大是32位 也就是4294967295

晶振为50M的话 50M的计数值为1s 4294967295计数值约为85s

固最大定时时间为85s

但用嵌套while的话 最大可以支持定时4294967295*85s

非阻塞延时

如果采用非阻塞的话 直接改写第二种方法就好了：

void delay_ms(unsigned int ms) { SysTick->LOAD = 50000000/1000*ms-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 //while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 //SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 50000000/1000/1000*us-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 //while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 //SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }

将等待和关闭定时器语句去掉 在使用时加上判断即可变为阻塞：

delay_ms(500); while ((SysTick->CTRL & 0x00010000)==0); SysTick->CTRL = 0;

在非阻塞状态下 可以提交定时器后 去做别的事情 然后再来等待

不过这样又有一个弊端 那就是定时器会自动重载 可能做别的事情以后 定时器跑过了 然后就要等85s才能停下

故可以通过内部定时器来进行非阻塞延时函数的编写

基本上每个mcu的内部定时器都可以配置自动重载等功能 网上资料很多 这里就不再阐述了

位带操作 位带代码

M3、M4架构的单片机 其输出口地址为端口地址+20 输入为+16 M0架构的单片机 其输出口地址为端口地址+12 输入为+8 以ADuCM4050为列：

位带宏定义 #ifndef __GPIO_H__ #define __GPIO_H__ #include "ADuCM4050.h" #include "adi_gpio.h" #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) #define MEM_ADDR(addr) *((volatile unsigned long *)(addr)) #define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum)) #define GPIO0_ODR_Addr (ADI_GPIO0_BASE+20) //0x40020014 #define GPIO0_IDR_Addr (ADI_GPIO0_BASE+16) //0x40020010 #define GPIO1_ODR_Addr (ADI_GPIO1_BASE+20) //0x40020054 #define GPIO1_IDR_Addr (ADI_GPIO1_BASE+16) //0x40020050 #define GPIO2_ODR_Addr (ADI_GPIO2_BASE+20) //0x40020094 #define GPIO2_IDR_Addr (ADI_GPIO2_BASE+16) //0x40020090 #define GPIO3_ODR_Addr (ADI_GPIO3_BASE+20) //0x400200D4 #define GPIO3_IDR_Addr (ADI_GPIO3_BASE+16) //0x400200D0 #define P0_O(n) BIT_ADDR(GPIO0_ODR_Addr,n) //输出 #define P0_I(n) BIT_ADDR(GPIO0_IDR_Addr,n) //输入 #define P1_O(n) BIT_ADDR(GPIO1_ODR_Addr,n) //输出 #define P1_I(n) BIT_ADDR(GPIO1_IDR_Addr,n) //输入 #define P2_O(n) BIT_ADDR(GPIO2_ODR_Addr,n) //输出 #define P2_I(n) BIT_ADDR(GPIO2_IDR_Addr,n) //输入 #define P3_O(n) BIT_ADDR(GPIO3_ODR_Addr,n) //输出 #define P3_I(n) BIT_ADDR(GPIO3_IDR_Addr,n) //输入 #define Port0 (ADI_GPIO_PORT0) #define Port1 (ADI_GPIO_PORT1) #define Port2 (ADI_GPIO_PORT2) #define Port3 (ADI_GPIO_PORT3) #define Pin0 (ADI_GPIO_PIN_0) #define Pin1 (ADI_GPIO_PIN_1) #define Pin2 (ADI_GPIO_PIN_2) #define Pin3 (ADI_GPIO_PIN_3) #define Pin4 (ADI_GPIO_PIN_4) #define Pin5 (ADI_GPIO_PIN_5) #define Pin6 (ADI_GPIO_PIN_6) #define Pin7 (ADI_GPIO_PIN_7) #define Pin8 (ADI_GPIO_PIN_8) #define Pin9 (ADI_GPIO_PIN_9) #define Pin10 (ADI_GPIO_PIN_10) #define Pin11 (ADI_GPIO_PIN_11) #define Pin12 (ADI_GPIO_PIN_12) #define Pin13 (ADI_GPIO_PIN_13) #define Pin14 (ADI_GPIO_PIN_14) #define Pin15 (ADI_GPIO_PIN_15) void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag); void GPIO_BUS_OUT(unsigned int port,unsigned int num); void P0_BUS_O(unsigned int num); unsigned int P0_BUS_I(void); void P1_BUS_O(unsigned int num); unsigned int P1_BUS_I(void); void P2_BUS_O(unsigned int num); unsigned int P2_BUS_I(void); void P3_BUS_O(unsigned int num); unsigned int P3_BUS_I(void); #endif 总线函数 #include "ADuCM4050.h" #include "adi_gpio.h" #include "GPIO.h" void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag) { switch(port) { case 0:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; case 1:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; case 2:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; case 3:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; default:port=0;break; } } void GPIO_BUS_OUT(unsigned int port,unsigned int num) //num最大为0xffff { int i; for(i=0;i<16;i++) { GPIO_OUT(port,i,(num>>i)&0x0001); } } void P0_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P0_O(i)=(num>>i)&0x0001; } } unsigned int P0_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P0_I(i)<<i)&0xFFFF; } return num; } void P1_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P1_O(i)=(num>>i)&0x0001; } } unsigned int P1_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P1_I(i)<<i)&0xFFFF; } return num; } void P2_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P2_O(i)=(num>>i)&0x0001; } } unsigned int P2_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P2_I(i)<<i)&0xFFFF; } return num; } void P3_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P3_O(i)=(num>>i)&0x0001; } } unsigned int P3_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P3_I(i)<<i)&0xFFFF; } return num; } 一、位带操作理论及实践

位带操作的概念其实30年前就有了，那还是 CM3 将此能力进化，这里的位带操作是 8051 位寻址区的威力大幅加强版

位带区： 支持位带操作的地址区

位带别名： 对别名地址的访问最终作 用到位带区的访问上（注意：这中途有一个 地址映射过程）

位带操作对于硬件 I/O 密集型的底层程序最有用处

支持了位带操作后，可以使用普通的加载/存储指令来对单一的比特进行读写。在CM4中，有两个区中实现了位带。其中一个是SRAM区的最低1MB范围，第二个则是片内外设区的最低1MB范围。这两个区中的地址除了可以像普通的RAM一样使用外，它们还都有自己的“位带别名区”，位带别名区把每个比特膨胀成一个32位的字。当你通过位带别名区访问这些字时，就可以达到访问原始比特的目的。

位操作就是可以单独的对一个比特位读和写，类似与51中sbit定义的变量，stm32中通过访问位带别名区来实现位操作的功能 STM32中有两个地方实现了位带，一个是SRAM，一个是片上外设。 （1）位带本质上是一块地址区（例如每一位地址位对应一个寄存器）映射到另一片地址区（实现每一位地址位对应一个寄存器中的一位），该区域就叫做位带别名区，将每一位膨胀成一个32位的字。 （2）位带区的4个字节对应实际寄存器或内存区的一个位，虽然变大到4个字节，但实际上只有最低位有效（代表0或1）

只有位带可以直接用=赋值的方式来操作寄存器 位带是把寄存器上的每一位 膨胀到32位 映射到位带区 比如0x4002 0000地址的第0个bit 映射到位带区的0地址 那么其对应的位带映射地址为0x00 - 0x04 一共32位 但只有LSB有效 采用位带的方式用=赋值时 就是把位带区对应的LSB赋值 然后MCU再转到寄存器对应的位里面 寄存器操作时 如果不改变其他位上面的值 那就只能通过&=或者|=的方式进行

要设置0x2000 0000这个字节的第二个位bit2为1,使用位带操作的步骤有： 1、将1写入位 带别名区对应的映射地址（即0x22000008,因为1bit对应4个byte）； 2、将0x2000 0000的值 读取到内部的缓冲区（这一步骤是内核完成的，属于原子操作，不需要用户操作）； 3、将bit2置1，再把值写 回到0x2000 0000(属于原子操作，不需要用户操作)。

关于GPIO引脚对应的访问地址，可以参考以下公式 寄存器位带别名 = 0x42000000 + (寄存器的地址-0x40000000)32 + 引脚编号4

如：端口F访问的起始地址GPIOF_BASE

#define GPIOF ((GPIO_TypeDef *)GPIOF_BASE)

但好在官方库里面都帮我们定义好了 只需要在BASE地址加上便宜即可

例如：

GPIOF的ODR寄存器的地址 = GPIOF_BASE + 0x14

寄存器位带别名 = 0x42000000 + (寄存器的地址-0x40000000)32 + 引脚编号4

设置PF9引脚的话：

uint32_t *PF9_BitBand = *(uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR– 0x40000000) *32 + 9*4)

封装一下：

#define PFout(x) *(volatile uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR – 0x40000000) *32 + x*4)

现在 可以把通用部分封装成一个小定义：

#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) #define MEM_ADDR(addr) *((volatile unsigned long *)(addr)) #define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum))

那么 设置PF引脚的函数可以定义：

#define GPIOF_ODR_Addr (GPIOF_BASE+20) //0x40021414 #define GPIOF_IDR_Addr (GPIOF_BASE+16) //0x40021410 #define PF_O(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出 #define PF_I(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入

若使PF9输入输出则：

PF_O(9)=1; //输出高电平 uint8_t dat = PF_I(9); //获取PF9引脚的值

总线输入输出：

void PF_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PF_O(i)=(num>>i)&0x0001; } } unsigned int PF_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PF_I(i)<<i)&0xFFFF; } return num; }

STM32的可用下面的函数：

#ifndef __GPIO_H__ #define __GPIO_H__ #include "stm32l496xx.h" #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) #define MEM_ADDR(addr) *((volatile unsigned long *)(addr)) #define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum)) #define GPIOA_ODR_Addr (GPIOA_BASE+20) //0x40020014 #define GPIOB_ODR_Addr (GPIOB_BASE+20) //0x40020414 #define GPIOC_ODR_Addr (GPIOC_BASE+20) //0x40020814 #define GPIOD_ODR_Addr (GPIOD_BASE+20) //0x40020C14 #define GPIOE_ODR_Addr (GPIOE_BASE+20) //0x40021014 #define GPIOF_ODR_Addr (GPIOF_BASE+20) //0x40021414 #define GPIOG_ODR_Addr (GPIOG_BASE+20) //0x40021814 #define GPIOH_ODR_Addr (GPIOH_BASE+20) //0x40021C14 #define GPIOI_ODR_Addr (GPIOI_BASE+20) //0x40022014 #define GPIOA_IDR_Addr (GPIOA_BASE+16) //0x40020010 #define GPIOB_IDR_Addr (GPIOB_BASE+16) //0x40020410 #define GPIOC_IDR_Addr (GPIOC_BASE+16) //0x40020810 #define GPIOD_IDR_Addr (GPIOD_BASE+16) //0x40020C10 #define GPIOE_IDR_Addr (GPIOE_BASE+16) //0x40021010 #define GPIOF_IDR_Addr (GPIOF_BASE+16) //0x40021410 #define GPIOG_IDR_Addr (GPIOG_BASE+16) //0x40021810 #define GPIOH_IDR_Addr (GPIOH_BASE+16) //0x40021C10 #define GPIOI_IDR_Addr (GPIOI_BASE+16) //0x40022010 #define PA_O(n) BIT_ADDR(GPIOA_ODR_Addr,n) //输出 #define PA_I(n) BIT_ADDR(GPIOA_IDR_Addr,n) //输入 #define PB_O(n) BIT_ADDR(GPIOB_ODR_Addr,n) //输出 #define PB_I(n) BIT_ADDR(GPIOB_IDR_Addr,n) //输入 #define PC_O(n) BIT_ADDR(GPIOC_ODR_Addr,n) //输出 #define PC_I(n) BIT_ADDR(GPIOC_IDR_Addr,n) //输入 #define PD_O(n) BIT_ADDR(GPIOD_ODR_Addr,n) //输出 #define PD_I(n) BIT_ADDR(GPIOD_IDR_Addr,n) //输入 #define PE_O(n) BIT_ADDR(GPIOE_ODR_Addr,n) //输出 #define PE_I(n) BIT_ADDR(GPIOE_IDR_Addr,n) //输入 #define PF_O(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出 #define PF_I(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入 #define PG_O(n) BIT_ADDR(GPIOG_ODR_Addr,n) //输出 #define PG_I(n) BIT_ADDR(GPIOG_IDR_Addr,n) //输入 #define PH_O(n) BIT_ADDR(GPIOH_ODR_Addr,n) //输出 #define PH_I(n) BIT_ADDR(GPIOH_IDR_Addr,n) //输入 #define PI_O(n) BIT_ADDR(GPIOI_ODR_Addr,n) //输出 #define PI_I(n) BIT_ADDR(GPIOI_IDR_Addr,n) //输入 void PA_BUS_O(unsigned int num); unsigned int PA_BUS_I(void); void PB_BUS_O(unsigned int num); unsigned int PB_BUS_I(void); void PC_BUS_O(unsigned int num); unsigned int PC_BUS_I(void); void PD_BUS_O(unsigned int num); unsigned int PD_BUS_I(void); void PE_BUS_O(unsigned int num); unsigned int PE_BUS_I(void); void PF_BUS_O(unsigned int num); unsigned int PF_BUS_I(void); void PG_BUS_O(unsigned int num); unsigned int PG_BUS_I(void); void PH_BUS_O(unsigned int num); unsigned int PH_BUS_I(void); void PI_BUS_O(unsigned int num); unsigned int PI_BUS_I(void); #endif #include "GPIO.h" void PA_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PA_O(i)=(num>>i)&0x0001; } } unsigned int PA_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PA_I(i)<<i)&0xFFFF; } return num; } void PB_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PB_O(i)=(num>>i)&0x0001; } } unsigned int PB_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PB_I(i)<<i)&0xFFFF; } return num; } void PC_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PC_O(i)=(num>>i)&0x0001; } } unsigned int PC_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PC_I(i)<<i)&0xFFFF; } return num; } void PD_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PD_O(i)=(num>>i)&0x0001; } } unsigned int PD_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PD_I(i)<<i)&0xFFFF; } return num; } void PE_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PE_O(i)=(num>>i)&0x0001; } } unsigned int PE_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PE_I(i)<<i)&0xFFFF; } return num; } void PF_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PF_O(i)=(num>>i)&0x0001; } } unsigned int PF_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PF_I(i)<<i)&0xFFFF; } return num; } void PG_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PG_O(i)=(num>>i)&0x0001; } } unsigned int PG_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PG_I(i)<<i)&0xFFFF; } return num; } void PH_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PH_O(i)=(num>>i)&0x0001; } } unsigned int PH_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PH_I(i)<<i)&0xFFFF; } return num; } void PI_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PI_O(i)=(num>>i)&0x0001; } } unsigned int PI_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PI_I(i)<<i)&0xFFFF; } return num; } 二、如何判断MCU的外设是否支持位带

根据《ARM Cortex-M3与Cortex-M4权威指南(第3版)》中第6章第7节描述 也就是说 要实现对GPIO的位带操作 必须保证GPIO位于外设区域的第一个1MB中 第一个1MB应该是0x4010 0000之前 位带不是直接操作地址 而是操作地址映射 地址映射被操作以后 MCU自动会修改对应寄存器的值

位带区只有1MB 所以只能改0x4000 0000 - 0x400F FFFF的寄存器 像F4系列 GPIO的首地址为0x4002 0000 就可以用位带来更改

STM32L476的GPIO就不行： AHB2的都不能用位带 ABP 还有AHB1都可以用 但是L476的寄存器里面 GPIO和ADC都是AHB2