1.位操作符
1.1位与&
（1）注意：位与符号是一个&，两个&&是逻辑与。
（2）真值表：1&0=0 1&1=1 0&0=0 0&1=0
（3）从真值表可以看出：位与操作的特点是：只有1和1位与结果为1，其余全是0。
（4）位与和逻辑与的区别：位与时两个操作数是按照二进制位彼此对应位相与的，逻辑与是两个操作数作为整体来相与的。（举例：0xAA&0xF0=0xA0 0xAA&&0xF0=1）
1.2位或|
（1）注意：位或符号是一个|，两个||是逻辑或。
（2）真值表：1|0=1 1|1=1 0|0=0 0|1=1
（3）从真值表可以看出：位或操作的特点是：只有两个0相位或才能得到0，只要有一个1，结果就为1。
（4）位或和逻辑或的区别：位或时两个操作数是按照二进制彼此对应位相或的，逻辑或是两个操作数作为整体来相或的。
1.3位取反~
（1）注意：C语言中位取反是~，C语言中的逻辑取反是！
（2）安慰取反试讲操作数的二进制位逐个按位取反（1变成0,0变成1）；而逻辑取反是真（在C语言中只要不是0的任何数都是真）变成假（在C语言中只有0表示假）、假变成真。
结论：
任何非0的数被按逻辑取反再取反就会得到1；
任何非0的数被按位取反再取反就会得到它自己。
1.4位异或^
（1）位异或真值表：1^1=0、0^0=0、1^0=1、0^1=1
（2）位异或的特点：2个数如果相等结果为0，不等结果为1。记忆方法：异或就是相异就或操作起来。
位与、位或、位异或的特点总结：
位与：（任何数，其实就是1或者0）与1位与无变化，与0位与变成0。
位或：（任何数，其实就是1或者0）与1位或变成1，与0位或无变化。
位异或：（任何数，其实就是1或者0）与1位异或会取反，与0位异或无变化。
1.5左移<<、右移>>
C语言的移位要取决于数据类型
对于无符号数，左移时右侧补0（相当于逻辑移位）
对于无符号数，右移时左侧补0（相当于逻辑移位）
对于有符号数，左移时右侧补0（叫算术移位，相当于逻辑移位）
对于有符号数，右移时左侧补补符号位（如果正数就补0，负数就补1，叫算术移位）
嵌入式中大多数研究的移位都是无符号数。
2.位与位或位异或在操作寄存器时的特殊作用
2.1寄存器操作的需求（特定位改变不影响其他位）
（1）ARM是内存与IO统一编址的，ARM中有很多内部外设，Soc中CPU通过这些内部外设的寄存器写入一些特定的值来操控这个内部外设，进而操控硬件动作。所以可以说：读写寄存器就是操控硬件。
（2）寄存器的特点是按位进行规划和使用。但是寄存器的读写确实是整体32位一起进行的（也就是说你只想修改bit5—bit7是不行的，必须整体32位全部写入）。
（3）如何做到？答案是：读、改、写三部曲。读改写的操作理念，就是：当我想改变一个寄存区中某些特定位时，我不会直接去给他写，我会先读出寄存器整体原来的值，然后在这个基础上修改我想要修改的特定位，再将修改后的值整体写入寄存器。这样达到的效果是：在不影响其他原来值的情况下，我关心的位的值已经被修改了。
2.2特定位清零用&
（1）位与的操作特点：任何数，其实就是1或者0）与1位与无变化，与0位与变成0。
（2）如果希望讲一个寄存器的某些特定位变成0而不影响其他位，可以构造一个合适的1和0组成的数和这个寄存器原来的值进行位与操作，就可以将特定位清零。
（3）举例：①假设原来32位寄存器中的值为0xAAAAAAAA，我们希望将bit8—bit15清零而其他位不变，可以将这个数0xFFFF00FF进行位与即可。
int main(void)
{
unsigned int a = 0x12aaaaa7;
unsigned int b = 0xFFFF00FF;
unsigned int c;
c = a & b;
printf("a&b=0x%x.\n", c); //12aa00a7
}
②把一个寄存器值的bit13—bit21清0，其他位不变。使用寄存器查看器https://pan.baidu.com/s/1Ija0klYH1JgqADiOLhpLxQ
int main(void)
{
unsigned int a = 0x123dc57;
unsigned int b = 0xffc01fff; //这个值是朱老师开发的寄存器查看器去操作得到的。
unsigned int c;
c = a & b;
printf("a&b=0x%x.\n", c); //12000c57
}
2.3特定位置1用|
（1）位或操作的特点：（任何数，其实就是1或者0）与1位或变成1，与0位或无变化。
（2）操作方法与上一节相类似，我们要构造一个这样的数：要置1的特定位为1，其他位为0，然后将这个数与原来的数进行位或操作即可。
举例：摆个寄存器值的bit4—bit7置1，其他位不变
int main(void)
{
unsigned int a = 0x123dc57;
unsigned int b = 0xf0; //因为f左边都为0所以可以省略
unsigned int c;
c = a | b;
printf("a|b=0x%x.\n", c); //123d0cf7
}
2.4特定位取反用^
（1）位异或操作的特点：（任何数，其实就是1或者0）与1位异或会取反，与0位异或无变化。
（2）操作手法和上一节讲的位与类似。我们要构造这样一个数：要取反的特定位为1，其他位为0，然后将这个数与原来的数进行位异或操作即可。
举例：把一个寄存器值的bit4—bit7取反，其他位不变。
int main(void)
{
unsigned int a = 0x123dc57;
unsigned int b = 0xf0; //因为f左边都为0所以可以省略
unsigned int c;
c = a ^ b;
printf("a^b=0x%x.\n", c);
}
3.如何用位运算构建特定二进制数
3.1寄存器位操作经常需要特定位给特定值
（1）对寄存器位操作经常需要特定位给特定值或者取反，关键性的难点在于要事先构建一个特别的数，这个数和原来的值进行位与、位或、位异或操作，即可达到我们对寄存器操作的要求。
（2）解法1：用工具如阿健或者计算器或者大脑计算，直接给出完整的32位特定数，比较难。
优势：可以完成工作，难度也不大，操作起来也不是太麻烦。
劣势：依赖工具，而且不是很直观，读程序的人不容易理解。
评价：凑合能用，但是不好用，应该被更好的方法代替。
（3）解法2：自己写代码用位操作符号（主要是移位和位取反）来构建这个特定的二进制数。
3.2使用移位获取特定位为1的二进制数
（1）最简单的就是用移位来获取一个特定位为1的二进制数。比如我们需要一个bit3~bit7为1（隐含的意思就是其他位全部为0）的二进制数，可以这样：（0
x1f<<3）。 0x1f代表11111，在16进制数来看，后四位为一个f，加上第五位1，就是0x1f。
（2）更难一点的要求：获取bit3~bit7为1，bit23~bit25为1，其余位为0的数：((0x1f<<3) | (7<<23)) 这里的7代表111
int main(void)
{
unsigned int a;
a = ((0x1f<<3) | (7<<23));
printf("a=0x%x.\n", a); // 0x38000f8
return 0;
}
((0x1f<<3) | (7<<23))移位解析：
位或说明这个数字由2部分组成，第一部分中左移3位说明第一部分从bit3开始，第一部分数字为0x1f说明这部分有5位，所以第一部分其实就是bit3~bit7；第二部分的解读方法是同样的，数字0x7说明这部分有3位，第二部分就是bit23到bit25；所以这两部分结合起来就是bit3~bit7和bit23~bit25为1，其余位全部为0。
3.3再结合位取反获取特定位为0的二进制数
（1）这次我们要获取bit4~bit10为0，其余位全部为1的数。怎么做？
（2）利用上面讲的方法就可以得到：(0xf<<0) | (0x1fffff<<11) 这个意思就是03和1131为1，这样取。但是问题在于，连续为1的数太多了，这个数本身就很难构造，所以这种方法的优势就没了。
（3）这种特定位（比较少）为0而其余位（比较多）为1的数，不适合很多个连续1左移的方式来构造，适合左移+位取反的方式来构造。这里所说bit4~bit10为0，那我就让它bit4~bit10为1，然后取反。
（4）思路是：先试图构造出这个数的位相反数，再取反得到这个数。比如本例中要构造的数bit4~bit10为0，其余位为1，那我们就先构造一个bit4~bit10为1，其余位为0的数，然后对这个数按位取反即可。
int main(void)
{
//聪明的方法
unsigned int a;
a = ~(0x7f<<4);
printf("a = 0x%x.\n", a);
//笨方法
unsigned int a;
a = (0xf<<0) | (0x1fffff<<11);
printf("a = 0x%x.\n", a);
return 0 ;
}
3.4总结：位与、位或结合特定二进制数即可完成寄存器位操作需求
（1）如果你要的这个数比较少为1，大部分为0，则可以通过连续很多个1左移n位得到构造数。
（2）如果你想要的数比较少为0，大部分为1，则可以通过构造其位反数，然后再取反来得到构造数。
（3）如果你想要的数中连续1（连续0）的部分不止1个，那么可以通过多段分别构造，然后再彼此位或即可。这时候因为参与位或运算的各个数为1的位是不重复的，所以这时候的位或其实相当于几个数的叠加。
4.位运算实战操作
4.1给定一个整型数a，设置a的bit3，保证其他位不变。
a = a | (1<<3); 或者 a |= (1<<3);
4.2给定一个整型数，设置a的bit3~bit7，保持其他位不变。
a = a | (0b11111<<3); 或者 a |= (0x1f<<3);
4.3给定一个整型数a，清除a的bit15，保证其他位不变。
a = a & (~(1<<15)); 或者 a &= (~(1<<15));
4.4给定一个整型数a，清除a的bit15~bit23，保持其他位不变。
a = a & (~(0x1ff<<15)); 或者 a &= (~(0x1ff<<15));
4.5给定一个整型数a，取出a的bit3~bit8。
思路：
第一步，先将这个数bit3~bit8不变，其余位全部清零；
第二步，再将其右移3位得到结果；
第三步，想明白上面的2步算法，再将其转换为C语言实现即可。
int main(void)
{
unsigned int a;
// 第一步，先将这个数bit3\~bit8不变，其余位全部清零
a &= (0x3f<<3);
// 第二步，再将其右移3位得到结果
printf("a = 0x%x.\n", a);
a >>= 3; //右移置底，即可解析为那个数值
printf("a = %u.\n", a);
return 0;
}
4.6用C语言给一个寄存器的bit7~bit17赋值937（其余位不受影响）。
关键：第一，不能影响其他位；第二，你并不知道原来bit7~bit17中装的值。
思路：
第一步，先将bit7~bit17全部清零，当然不能影响其他位； a &= (~(0x7ff<<7));
第二步，把937写入bit7~bit17即可。 a |= (937<<7);
int main(void)
{
unsigned int a = 0xc30288f8;
// 第一步，先将bit7~bit17全部清零
a &= (~(0x7ff<<7));
// 第二步，把937写入bit7~bit17
a |= (937<<7);
printf("a = 0x%x.\n", a);
return 0 ;
}
4.7用C语言将一个寄存器的bit7~bit17的值加17（其余位不受影响）。
关键：不知道原来的值是多少。
思路：
第一步，先读出原来bit7~bit17的值；
第二步，给这个值加17；
第三步，将bit7~bit17清零；
第四步，将第二步算出来的值写入bit7~bit17。
int main(void)
{
unsiged int a = 0x0xc30288f8;
// 第一步，先读出原来bit7~bit17的值；
unsigned int tmp;
tmp >>= 7;
// 第二步，给这个值加17；
tmp += 17;
// 第三步，将bit7~bit17清零；
a &= ~(0x7ff<<7);
// 第四步，将第二步算出来的值写入bit7~bit17。
a |= tmp;
printf("a = 0x%x.\n", a);
return 0 ;
}
4.8用C语言给一个寄存器的bit7~bit17赋值937，同时bit21~bit25的值加17。
思路：2倍的4.6代码即可
int main(void)
{
unsigned int a = 0xc30288f8;
// bit7~bit17赋值937
a &= ~(0x7ff<<7);
a |= (937<<7);
// bit21~bit25的值加17
a &= ~(0x1f<<21);
a |= 17<<21;
printf("a = 0x%x.\n", a);
return 0 ;
}
分析：
上面写两次代码也可以，但是效率不高，可以将上面的两步合二为一。
a &= ~( (0x7ff<<7) | (0x1f<<21));
a |= ((937<<7) | (17<<21))
扩展：一般像937、17这样的常数，一般都会使用宏定义来代替，类似于a |= ((VALUE1<<7) | (VALUE2<<21));
5.技术升级：用宏定义来完成位运算（面试常考）
（1）用宏定义将32位数x的第n位（右边起算，也就是bit0算第一位）置位。
#define SET_BIT_N(x, n) (x | (1U<<(n-1)))
（2）用宏定义将32位数x的第n位（右边起算，也就是bit0算第一位）清零。
#define CLEAR_BIT_N(x, n) (x & ~(1U<<(n-1)))
（3）用宏定义将32位数x的第n位到第m位（右边起算，也就是bit0算第一位，m是高位）置位。
假如n=3，m=6，题目就是要把bit2到bit5置位，我们需要一个算式来得到（m-n+1）个1。
思路：
第一步，先得到32位1：~0U
第二步，将第一步等到的数右移x位即可得到（m-n+1）个1，即(~0U >> (32-(m-n+1)))
得到最终式子：#define SET_BIT_N_M(x, n, m) (x | (((~0U) >> (32-(m-n+1)))<<(n-1)))
#include <stdio.h>
#define SET_BIT_N(x, n) (x | (1U<<(n-1)))
#define CLEAR_BIT_N(x, n) (x & ~(1U<<(n-1)))
#define SET_BIT_N_M(x, n, m) (x | (((~0U) >> (32-(m-n+1)))<<(n-1)))
int main(void)
{
// test foe SET_BIN_N
unsigned int a = 0;
unsigned int b = 0;
b = SET_BIT_N(a, 4);
printf("b = 0x%x.\n", b);
// test for CLEAR_BIT_N
unsigned int a = 0xFFFFFFFF;
unsigned int b = 0;
b = CLEAR_BIT_N(a, 4);
printf("b = 0x%x.\n", b);
// test for SET_BIT_N_M
unsigned int a = 0x0;
unsigned int b = 0;
b = SET_BIT_N_M(a, 1, 4);
printf("b = 0x%x.\n", b);
return 0;
}
6.着重分析复杂宏定义与位操作
题目：截取变量的部分连续位。变量0x88，也就是10001000b，若截取第2~4位，则值为：100b=4
Linux内核宏定义：#define GETBITS(x, n, m) ((x & ~(~0U)<<(m-n+1))<<(n-1))>>(n-1))
分析：
（1）先分清楚这个复杂宏分为几部分：2部分
(x & (0U)<<(m-n+1))<<(n-1)) 与 >>(n-1)
（2）继续解析剩下的：又分为2部分
x 与 (0U)<<(m-n+1))<<(n-1)
（3）继续分析：
~ 与 (~0U)<<(m-n+1)) 与>> (n-1)
优先级：~高于>>
