乐理燥废笔记
乐理燥废笔记
文章目录
- 终止式
- 小调音阶
- 转调
- 不协和和弦进行
- 大小转调
- 1251 1451转调
- 我的霹雳猫阿诺
- 三全音代理
- 五声音阶
- 又怎样和弦
- 附录：压缩字符串、大小端格式转换
-
- 压缩字符串
-
- 浮点数
- 压缩Packed-ASCII字符串
- 大小端转换
-
- 什么是大端和小端
- 数据传输中的大小端
- 总结
- 大小端转换函数
- 附录：Cortex-M架构的SysTick系统定时器精准延时和MCU位带操作
-
- SysTick系统定时器精准延时
-
- 延时函数
-
- 阻塞延时
- 非阻塞延时
- 位带操作
-
- 位带代码
-
- 位带宏定义
- 总线函数
- 一、位带操作理论及实践
- 二、如何判断MCU的外设是否支持位带
终止式
正格终止 五级和弦到一级终止
如G（G7）到C
半终止 停在五级和弦
假终止 五级和弦接到不是一级的终止
通常是接到六级 如G7到Am 有忧郁感
接到Ab 神圣感
Dbmaj9 慵懒
F#dim7 紧张
变格终止 四级和弦到一级的终止 （教会终止 阿门）
如F到C 唱阿门的时候可以用
小调音阶
在自然小调当中 C D Eb F G Ab Bb
采用某尾进行接到主音时 用五度小三和弦接 如Gm7-Cm
和声小音阶 C D Eb F G Ab B
变调接主音只在某尾进行
旋律小音阶 C D Eb F G A B
旋律往上走时升高6 7度音
往下走时恢复自然小音阶
转调
调性对置
直接首尾相连升调 （大小二度或三度）
比如C Am F G7 - D Bm G A7
近关系属七和弦转调（有共同和弦）
要有共同和弦以及转调和弦来进行过渡
转调和弦中最主要的是新调的属七和弦
比如C - F 共同和弦Am F的属七和弦C7
C Am C7 F 完成转调
远关系等音和弦转调（相差一个半音转调）
比如C - B
由两个调的属七和弦过渡C G7（E#dim7 也就是Fdim7 相当于G7和弦中的G变为G#） F#7 B
通过对B大调的重属导七和弦为增六和弦E#dim7的六级音G#降半音变成G 从而变成G7和弦进行等音和弦转调的方法 一般仅适用于主音相差一个半音的两个调
远关系交替和弦转调（没有共同和弦 但整体转调后有共同和弦）
比如C - Ab
C - Cm调下属共同和弦 - Ab属七和弦 - Ab
C Fm Eb7 Ab
转调需要有中介和弦 可以多次转调来达到目的效果
不协和和弦进行
第五级属7和弦接到一级和弦
代表作 让我留在你身边
C E7 Am G
G-G#-A-G
五级和弦喜欢接到一级和弦，形成一种解决，比如G7到C，故在C调Am和弦前面插入了它的第五级属七和弦E7
大小转调
大调转小调（C转Cm）
降EAB
小调转大调（Am转A）
升CFG
转调后升降为原调C或Am：
C Am F Dm大调转小调/小调转大调
Am F Dm G7（G7舍去）
Em C Am F（Em舍去）
大调转小调减三 小调按大调转小调减四
小调转大调增三 大调按小调转大调增四
含有C段落的C/Am歌曲只能用大调转小调
含有Dm段落的C/Am歌曲只能用小调转大调
既含有C段落也含有Dm段落的歌曲不能全以一个方式转 必须有一个转另外一个不转 这样又会导致转调方式不统一而造成某一段不转调所带来的旋律调差 一般不可取
1251 1451转调
前一个调12 后一个调51
或1451
且后一个调的五级和弦最高音 应与前一个调的第二个和弦最高音相近
我的霹雳猫阿诺
C Ionian 大调 CDEFGAB 明亮 以C开头为C大调
C D E F G A B
D Dorian DEFGABC 神话 以C开头为Bb大调
C D Eb F G A Bb
E Phrygian EFGABCD 西班牙 以C开头为Ab大调
C Db Eb F G Ab Bb
C Db E F G Ab Bb Phrygian Dominant 常用不协和调
F Lydian FGABCDE 梦幻 以C开头为G大调
C D E F# G A B
三度叠加有梦幻感觉 Cmaj13(#11)
切换一级二级和弦 英雄 浩瀚 CD
F#与G 有故意弹错音的感觉 滑稽感
G Mixolydian GABCDEF 蓝调 爵士 以C开头为F大调
C D E F G A Bb
A Aeolian 小调 ABCDEFG 悲伤 以C开头为Eb大调
C D Eb F G Ab Bb
B Locrian BCDEFGA 黑暗 以C开头为Db大调
C Db Eb F Gb Ab Bb
三全音代理
三全音代理
C调属七和弦G7
三全音听感不协和，性质不稳定，故而B和F两个音都有向旁边相距半音的位置进行解决的倾向。即B向C进行，F向E进行，从而变成一个不完全协和音程大三度。
G7和弦的G、B、D、F四个音便变成了G、C、D、E四个音。由于在属七和弦中，五音对于和弦性质的影响最小，故而D音可以省略，这样的话，我们就得到了G、C、E三个音，这三个音刚好构成了C大调的主和弦C和弦。
G7用三全音代理推得Db属七和弦，Db、F、Ab、B。和弦中的B音我们可以看作是Cb音，这样构成音就是Db、F、Ab、Cb了，标准的属七和弦的结构。在一些情况下如果能拿来代替G属七和弦的话，也许就会给你的和弦进行增色不少。
在任何和弦前面我们都可以接上一个根音比目标和弦高半音的属七和弦。比如Eb属七和弦到Dm和弦，Ab属七和弦到G和弦
五声音阶
大调五声音阶 （宫调式）
C D E G A
宫商角徵羽
全全小三全小三
小调五声音阶 （羽调式）
C Eb F G Bb 或 A C D E G （以A开头 以此类推宫商角徵羽五调式 类比我的霹雳猫阿洛）
又怎样和弦
吉他由低到高的后5弦EADGB可以接所有音
改变转位 根音不同 可以变成不同和弦
附录：压缩字符串、大小端格式转换
压缩字符串
首先HART数据格式如下：
重点就是浮点数和字符串类型
Latin-1就不说了 基本用不到
浮点数
浮点数里面 如 0x40 80 00 00表示4.0f
在HART协议里面 浮点数是按大端格式发送的 就是高位先发送 低位后发送
发送出来的数组为：40,80,00,00
但在C语言对浮点数的存储中 是按小端格式来存储的 也就是40在高位 00在低位
浮点数：4.0f
地址0x1000对应00
地址0x1001对应00
地址0x1002对应80
地址0x1003对应40
若直接使用memcpy函数 则需要进行大小端转换 否则会存储为：
地址0x1000对应40
地址0x1001对应80
地址0x1002对应00
地址0x1003对应00
大小端转换：
void swap32(void * p)
{
uint32_t *ptr=p;
uint32_t x = *ptr;
x = (x << 16) | (x >> 16);
x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);
*ptr=x;
}
压缩Packed-ASCII字符串
本质上是将原本的ASCII的最高2位去掉 然后拼接起来 比如空格(0x20)
四个空格拼接后就成了
1000 0010 0000 1000 0010 0000
十六进制：82 08 20
对了一下表 0x20之前的识别不了
也就是只能识别0x20-0x5F的ASCII表
压缩/解压函数后面再写：
//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_ASCII_to_Pack(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{
if(str_len%4)
{
return 0;
}
uint8_t i=0;
memset(buf,0,str_len/4*3);
for(i=0;i<str_len;i++)
{
if(str[i]==0x00)
{
str[i]=0x20;
}
}
for(i=0;i<str_len/4;i++)
{
buf[3*i]=(str[4*i]<<2)|((str[4*i+1]>>4)&0x03);
buf[3*i+1]=(str[4*i+1]<<4)|((str[4*i+2]>>2)&0x0F);
buf[3*i+2]=(str[4*i+2]<<6)|(str[4*i+3]&0x3F);
}
return 1;
}
//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_Pack_to_ASCII(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{
if(str_len%4)
{
return 0;
}
uint8_t i=0;
memset(str,0,str_len);
for(i=0;i<str_len/4;i++)
{
str[4*i]=(buf[3*i]>>2)&0x3F;
str[4*i+1]=((buf[3*i]<<4)&0x30)|(buf[3*i+1]>>4);
str[4*i+2]=((buf[3*i+1]<<2)&0x3C)|(buf[3*i+2]>>6);
str[4*i+3]=buf[3*i+2]&0x3F;
}
return 1;
}
大小端转换
在串口等数据解析中 难免遇到大小端格式问题
什么是大端和小端
所谓的大端模式，就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
所谓的小端模式，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
简单来说：大端——高尾端，小端——低尾端
举个例子，比如数字 0x12 34 56 78在内存中的表示形式为：
1)大端模式：
低地址 -----------------> 高地址
0x12 | 0x34 | 0x56 | 0x78
2)小端模式：
低地址 ------------------> 高地址
0x78 | 0x56 | 0x34 | 0x12
可见，大端模式和字符串的存储模式类似。
数据传输中的大小端
比如地址位、起止位一般都是大端格式
如：
起始位：0x520A
则发送的buf应为{0x52,0x0A}
而数据位一般是小端格式（单字节无大小端之分）
如：
一个16位的数据发送出来为{0x52,0x0A}
则对应的uint16_t类型数为： 0x0A52
而对于浮点数4.0f 转为32位应是：
40 80 00 00
以大端存储来说 发送出来的buf就是依次发送 40 80 00 00
以小端存储来说 则发送 00 00 80 40
由于memcpy等函数 是按字节地址进行复制 其复制的格式为小端格式 所以当数据为小端存储时 不用进行大小端转换
如：
uint32_t dat=0;
uint8_t buf[]={0x00,0x00,0x80,0x40};
memcpy(&dat,buf,4);
float f=0.0f;
f=*((float*)&dat); //地址强转
printf("%f",f);
或更优解：
uint8_t buf[]={0x00,0x00,0x80,0x40};
float f=0.0f;
memcpy(&f,buf,4);
而对于大端存储的数据（如HART协议数据 全为大端格式） 其复制的格式仍然为小端格式 所以当数据为小端存储时 要进行大小端转换
如：
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);
或：
uint8_t buf[]={0x40,0x80,0x00,0x00};
memcpy(&dat,buf,4);
float f=0.0f;
swap32(&f); //大小端转换
printf("%f",f);
或更优解：
uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};
float f=0.0f;
dat=(buf[0]<<24)|(buf[0]<<16)|(buf[0]<<8)|(buf[0]<<0)
f=*((float*)&dat);
总结
固 若数据为小端格式 则可以直接用memcpy函数进行转换 否则通过移位的方式再进行地址强转
对于多位数据 比如同时传两个浮点数 则可以定义结构体之后进行memcpy复制（数据为小端格式）
对于小端数据 直接用memcpy写入即可 若是浮点数 也不用再进行强转
对于大端数据 如果不嫌麻烦 或想使代码更加简洁（但执行效率会降低） 也可以先用memcpy写入结构体之后再调用大小端转换函数 但这里需要注意的是 结构体必须全为无符号整型 浮点型只能在大小端转换写入之后再次强转 若结构体内采用浮点型 则需要强转两次
所以对于大端数据 推荐通过移位的方式来进行赋值 然后再进行个别数的强转 再往通用结构体进行写入
多个不同变量大小的结构体 要主要字节对齐的问题
可以用#pragma pack(1) 使其对齐为1
但会影响效率
大小端转换函数
直接通过对地址的操作来实现 传入的变量为32位的变量
中间变量ptr是传入变量的地址
void swap16(void * p)
{
uint16_t *ptr=p;
uint16_t x = *ptr;
x = (x << 8) | (x >> 8);
*ptr=x;
}
void swap32(void * p)
{
uint32_t *ptr=p;
uint32_t x = *ptr;
x = (x << 16) | (x >> 16);
x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);
*ptr=x;
}
void swap64(void * p)
{
uint64_t *ptr=p;
uint64_t x = *ptr;
x = (x << 32) | (x >> 32);
x = ((x & 0x0000FFFF0000FFFF) << 16) | ((x >> 16) & 0x0000FFFF0000FFFF);
x = ((x & 0x00FF00FF00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF00FF00FF);
*ptr=x;
}
附录：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