你的位置： >
> 手把手教你零基础学单片机教程（第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系）
本来这一节打算讲大数据的加法运算的，但是考虑大数据运算的基础是非组合BCD码，所以多增加一节讲BCD码的内容。
计算机中的BCD码，经常使用的有两种格式，即组合BCD码，非组合BCD码。
组合BCD码，是将两位十进制数，存放在一个字节中，例如：十进制数51的存放格式是。
非组合BCD码，是将一个字节的低四位编码表示十进制数的一位，而高4位都为0。例如：十进制数51的占用了两个字节的空间，存放格式为：00001。
这一节要教大家两个知识点：
第一个：如何编写组合BCD码，非组合BCD码，以及数值三者之间的相互转换函数。
第二个：通过转换函数的编写，重温前面几节所讲到的指针用法。
具体内容，请看源代码讲解。
（1）硬件平台：
基于51单片机学习板。
（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送EB 00 55 XX YY YY … YY YY 指令，其中EB 00 55是数据头，XX 是指令类型。YY是具体的数据。
指令类型01代表发送的是数值，需要转成组合BCD码和非组合BCD码，并且返回上位机显示。
指令类型02代表发送的是组合BCD码，需要转成数值和非组合BCD码，并且返回上位机显示。
指令类型03代表发送的是非组合BCD码，需要转成数值和组合BCD码，并且返回上位机显示。
返回上位机的数据中，中间3个数据EE EE EE是分割线，为了方便观察，没实际意义。
例如：十进制的数据，它的十六进制数据是03 19 A8 54。
（a）上位机发送数据：eb 00 55 01 03 19 a8 54
单片机返回：52 01 31 40 EE EE EE 05 02 00 01 03 01 04 00
（b）上位机发送组合BCD码：eb 00 55 02 52 01 31 40
单片机返回：03 19 A8 54 EE EE EE 05 02 00 01 03 01 04 00
（c）发送非组合BCD码：eb 00 55 03 05 02 00 01 03 01 04 00
单片机返回：03 19 A8 54 EE EE EE 52 01 31 40
（3）源代码讲解如下：
#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
/* 注释一：
* 注意，此处的const_rc_size是20，比之前章节的缓冲区稍微改大了一点。
#define const_rc_size 20 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4);//把数值转换成组合BCD码
void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8);//把数值转换成非组合BCD码
void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber); //组合BCD码转成数值
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8); //组合BCD码转成非组合BCD码
void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber); //非组合BCD码转成数值
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4); //非组合BCD码转成组合BCD码
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int uiRcMoveIndex=0; //用来解析数据协议的中间变量
/* 注释二：
* 注意，本程序规定数值的最大范围是0至
* 数组中的数据。高位在数组下标大的方向，低位在数组下标小的方向。
unsigned char ucBufferNumber[4]; //数值，用4个字节表示long类型的数值
unsigned char ucBufferBCB_bit4[4]; //组合BCD码
unsigned char ucBufferBCB_bit8[8]; //非组合BCD码
void main()
initial_myself();
delay_long(100);
initial_peripheral();
usart_service(); //串口服务程序
void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4)//把数值转换成组合BCD码
unsigned long ulNumberTemp=0;
unsigned char ucTemp=0;
ulNumberTemp=p_ucNumber[3]; //把4个字节的数值合并成一个long类型数据
ulNumberTemp=ulNumberTemp&&8;
ulNumberTemp=ulNumberTemp+p_ucNumber[2];
ulNumberTemp=ulNumberTemp&&8;
ulNumberTemp=ulNumberTemp+p_ucNumber[1];
ulNumberTemp=ulNumberTemp&&8;
ulNumberTemp=ulNumberTemp+p_ucNumber[0];
p_ucBCD_bit4[3]=ulNumberTemp%000000;
p_ucBCD_bit4[3]=p_ucBCD_bit4[3]&&4; //前半4位存第8位组合BCD码
ucTemp=ulNumberTemp%0000;
p_ucBCD_bit4[3]=p_ucBCD_bit4[3]+ucT //后半4位存第7位组合BCD码
p_ucBCD_bit4[2]=ulNumberTemp%000;
p_ucBCD_bit4[2]=p_ucBCD_bit4[2]&&4; //前半4位存第6位组合BCD码
ucTemp=ulNumberTemp%00;
p_ucBCD_bit4[2]=p_ucBCD_bit4[2]+ucT//后半4位存第5位组合BCD码
p_ucBCD_bit4[1]=ulNumberTemp%;
p_ucBCD_bit4[1]=p_ucBCD_bit4[1]&&4; //前半4位存第4位组合BCD码
ucTemp=ulNumberTemp%;
p_ucBCD_bit4[1]=p_ucBCD_bit4[1]+ucT//后半4位存第3位组合BCD码
p_ucBCD_bit4[0]=ulNumberTemp%100/10;
p_ucBCD_bit4[0]=p_ucBCD_bit4[0]&&4; //前半4位存第2位组合BCD码
ucTemp=ulNumberTemp%10;
p_ucBCD_bit4[0]=p_ucBCD_bit4[0]+ucT//后半4位存第1位组合BCD码
void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8)//把数值转换成非组合BCD码
unsigned long ulNumberTemp=0;
ulNumberTemp=p_ucNumber[3]; //把4个字节的数值合并成一个long类型数据
ulNumberTemp=ulNumberTemp&&8;
ulNumberTemp=ulNumberTemp+p_ucNumber[2];
ulNumberTemp=ulNumberTemp&&8;
ulNumberTemp=ulNumberTemp+p_ucNumber[1];
ulNumberTemp=ulNumberTemp&&8; ulNumberTemp=ulNumberTemp+p_ucNumber[0]; p_ucBCD_bit8[7]=ulNumberTemp%000000;//一个字节8位存储第8位非组合BCD码 p_ucBCD_bit8[6]=ulNumberTemp%0000;//一个字节8位存储第7位非组合BCD码 p_ucBCD_bit8[5]=ulNumberTemp%000;//一个字节8位存储第6位非组合BCD码 p_ucBCD_bit8[4]=ulNumberTemp%00;//一个字节8位存储第5位非组合BCD码 p_ucBCD_bit8[3]=ulNumberTemp%;//一个字节8位存储第4位非组合BCD码 p_ucBCD_bit8[2]=ulNumberTemp%;//一个字节8位存储第3位非组合BCD码 p_ucBCD_bit8[1]=ulNumberTemp%100/10;//一个字节8位存储第2位非组合BCD码 p_ucBCD_bit8[0]=ulNumberTemp%10;//一个字节8位存储第1位非组合BCD码 } void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber) //组合BCD码转成数值 { unsigned long ulT unsigned long ulS ulSum=0; //累加和数值清零 ulTmep=0; ulTmep=p_ucBCD_bit4[3]; ulTmep=ulTmep&&4; //把组合BCD码第8位分解出来
ulTmep=ulTmep*;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[3];
ulTmep=ulTmep&0x0000000f; //把组合BCD码第7位分解出来
ulTmep=ulTmep*1000000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[2];
ulTmep=ulTmep&&4; //把组合BCD码第6位分解出来
ulTmep=ulTmep*100000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[2];
ulTmep=ulTmep&0x0000000f; //把组合BCD码第5位分解出来
ulTmep=ulTmep*10000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[1];
ulTmep=ulTmep&&4; //把组合BCD码第4位分解出来
ulTmep=ulTmep*1000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[1];
ulTmep=ulTmep&0x0000000f; //把组合BCD码第3位分解出来
ulTmep=ulTmep*100;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[0];
ulTmep=ulTmep&&4; //把组合BCD码第2位分解出来
ulTmep=ulTmep*10;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit4[0];
ulTmep=ulTmep&0x0000000f; //把组合BCD码第1位分解出来
ulTmep=ulTmep*1;
ulSum=ulSum+ulT //累加各位数值
//以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。
p_ucNumber[3]=ulSum&&24; //把long类型数据分解成4个字节
p_ucNumber[2]=ulSum&&16;
p_ucNumber[1]=ulSum&&8;
p_ucNumber[0]=ulS
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8) //组合BCD码转成非组合BCD码
unsigned char ucT
ucTmep=p_ucBCD_bit4[3];
p_ucBCD_bit8[7]=ucTmep&&4; //把组合BCD码第8位分解出来
p_ucBCD_bit8[6]=ucTmep&0x0f; //把组合BCD码第7位分解出来
ucTmep=p_ucBCD_bit4[2];
p_ucBCD_bit8[5]=ucTmep&&4; //把组合BCD码第6位分解出来
p_ucBCD_bit8[4]=ucTmep&0x0f; //把组合BCD码第5位分解出来
ucTmep=p_ucBCD_bit4[1];
p_ucBCD_bit8[3]=ucTmep&&4; //把组合BCD码第4位分解出来
p_ucBCD_bit8[2]=ucTmep&0x0f; //把组合BCD码第3位分解出来
ucTmep=p_ucBCD_bit4[0];
p_ucBCD_bit8[1]=ucTmep&&4; //把组合BCD码第2位分解出来
p_ucBCD_bit8[0]=ucTmep&0x0f; //把组合BCD码第1位分解出来
void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber) //非组合BCD码转成数值
unsigned long ulT
unsigned long ulS
ulSum=0; //累加和数值清零
ulTmep=p_ucBCD_bit8[7];
ulTmep=ulTmep*;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[6];
ulTmep=ulTmep*1000000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[5];
ulTmep=ulTmep*100000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[4];
ulTmep=ulTmep*10000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[3];
ulTmep=ulTmep*1000;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[2];
ulTmep=ulTmep*100;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[1];
ulTmep=ulTmep*10;
ulSum=ulSum+ulT //累加各位数值
ulTmep=p_ucBCD_bit8[0];
ulTmep=ulTmep*1;
ulSum=ulSum+ulT //累加各位数值
//以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。
p_ucNumber[3]=ulSum&&24; //把long类型数据分解成4个字节
p_ucNumber[2]=ulSum&&16;
p_ucNumber[1]=ulSum&&8;
p_ucNumber[0]=ulS
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4) //非组合BCD码转成组合BCD码
unsigned char ucT
ucTmep=p_ucBCD_bit8[7]; //把非组合BCD码第8位分解出来
p_ucBCD_bit4[3]=ucTmep&&4;
p_ucBCD_bit4[3]=p_ucBCD_bit4[3]+p_ucBCD_bit8[6]; //把非组合BCD码第7位分解出来
ucTmep=p_ucBCD_bit8[5]; //把非组合BCD码第6位分解出来
p_ucBCD_bit4[2]=ucTmep&&4;
p_ucBCD_bit4[2]=p_ucBCD_bit4[2]+p_ucBCD_bit8[4]; //把非组合BCD码第5位分解出来
ucTmep=p_ucBCD_bit8[3]; //把非组合BCD码第4位分解出来
p_ucBCD_bit4[1]=ucTmep&&4;
p_ucBCD_bit4[1]=p_ucBCD_bit4[1]+p_ucBCD_bit8[2]; //把非组合BCD码第3位分解出来
ucTmep=p_ucBCD_bit8[1]; //把非组合BCD码第2位分解出来
p_ucBCD_bit4[0]=ucTmep&&4; p_ucBCD_bit4[0]=p_ucBCD_bit4[0]+p_ucBCD_bit8[0]; //把非组合BCD码第1位分解出来 } void usart_service(void) //串口服务程序,在main函数里 { unsigned char i=0; if(uiSendCnt&=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
while(uiRcregTotal&=5&&uiRcMoveIndex&=(uiRcregTotal-5))
if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55) //数据头eb 00 55的判断
switch(ucRcregBuf[uiRcMoveIndex+3]) //根据命令类型来进行不同的处理
case 1: //接收到的是数值，需要转成组合BCD码和非组合BCD码
for(i=0;i&4;i++)
ucBufferNumber[3-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的数据，注意，高位在数组下标大的方向
number_to_BCD4(ucBufferNumber,ucBufferBCB_bit4);//把数值转换成组合BCD码
number_to_BCD8(ucBufferNumber,ucBufferBCB_bit8);//把数值转换成非组合BCD码
for(i=0;i&4;i++)
eusart_send(ucBufferBCB_bit4[3-i]); ////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
for(i=0;i&8;i++)
eusart_send(ucBufferBCB_bit8[7-i]); ////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
case 2: //接收到的是组合BCD码，需要转成数值和非组合BCD码
for(i=0;i&4;i++)
ucBufferBCB_bit4[3-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的组合BCD码，注意，高位在数组下标大的方向
BCD4_to_number(ucBufferBCB_bit4,ucBufferNumber); //组合BCD码转成数值
BCD4_to_BCD8(ucBufferBCB_bit4,ucBufferBCB_bit8); //组合BCD码转成非组合BCD码
for(i=0;i&4;i++)
eusart_send(ucBufferNumber[3-i]); ////把数值返回给上位机观察，注意，高位在数组下标大的方向
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
for(i=0;i&8;i++)
eusart_send(ucBufferBCB_bit8[7-i]); ////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
case 3: //接收到的是非组合BCD码，需要转成数值和组合BCD码
for(i=0;i&8;i++)
ucBufferBCB_bit8[7-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的非组合BCD码，注意，高位在数组下标大的方向
BCD8_to_number(ucBufferBCB_bit8,ucBufferNumber); //非组合BCD码转成数值
BCD8_to_BCD4(ucBufferBCB_bit8,ucBufferBCB_bit4); //非组合BCD码转成组合BCD码
for(i=0;i&4;i++)
eusart_send(ucBufferNumber[3-i]); ////把数值返回给上位机观察
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为分割线，注意，高位在数组下标大的方向
eusart_send(0xee);
eusart_send(0xee);
for(i=0;i&4;i++)
eusart_send(ucBufferBCB_bit4[3-i]); ////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
//退出循环
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendD //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
void T0_time(void) interrupt 1 //定时中断
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt&const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完 { uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来 ucSendLock=1; //开自锁标志 } TH0=0 //重装初始值()=65035=0xfe0b TL0=0x0b; TR0=1; //开中断 } void usart_receive(void) interrupt 4 //串口接收数据中断 { if(RI==1) { RI = 0; ++uiRcregT if(uiRcregTotal&const_rc_size) //超过缓冲区
uiRcregTotal=const_rc_
ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
uiSendCnt=0; //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
else //发送中断，及时把发送中断标志位清零
void delay_long(unsigned int uiDelayLong)
for(i=0;i&uiDelayLi++)
for(j=0;j&500;j++) //内嵌循环的空指令数量
; //一个分号相当于执行一条空语句
void delay_short(unsigned int uiDelayShort)
for(i=0;i&uiDelaySi++)
; //一个分号相当于执行一条空语句
void initial_myself(void) //第一区 初始化单片机
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
//配置定时器
TMOD=0x01; //设置定时器0为工作方式1
TH0=0 //重装初始值()=65035=0xfe0b
//配置串口
SCON=0x50;
TMOD=0X21;
TH1=TL1=-(/32/9600); //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
void initial_peripheral(void) //第二区 初始化外围
EA=1; //开总中断
ES=1; //允许串口中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
总结陈词：
有了这一节非组合BCD的基础知识，下一节就开始讲大数据的算法程序。这些算法程序经常要用在计算器，工控，以及高精度的仪器仪表等领域。C语言的语法中不是已经提供了+,-,*,/这些运算符号吗？为什么还要专门写算法程序？因为那些运算符只能进行简单的运算，一旦数据超过了unsigned long（4个字节）的范围就会出错。而这种大数据算法的程序是什么样的？欲知详情，请听下回分解—-大数据的加法运算。
转载请注明： &
与本文相关的文章常用的汇编指令整理（8086）
通用传送指令
最基本的传送指令
MOV&&AL，BL
&&&&&&&&&MOV&&ES，DX
&&&&&&&&&MOV&&AX，[BX]
&&&&&&&&&MOV&&[DI]，AX
&&&&&&&&&MOV&&CX，[1000]
&&&&&&&&&MOV&&BL，40
&&&&&&&&&MOV&&DX，1234H
&&&&&&&&&MOV&&WORD&PTR&[SI]，9876H
MOVZX&&EAX，BL
;BL被零扩展后送EAX
MOVSX&&EAX，BL
;BL被符号扩展后送EAX
堆栈操作指令
PUSH&&AX&&&&&&&&&&&&&&&&&&&&&&&&
PUSH&&DS&&&&&&&&&&&&&&&&&&&&&&&&&&
PUSH&&[BX+DI]
XCHG&&AX&&&&&，BX&
XCHG&[2530]&&，CX
XCHG&&EAX&&&&&，ESI
XCHG&&EAX&&&&&，[ESI]
BSWAP&&EAX&&&;寄存器内部字节的交换
如:[EAX]=H
指令执行后:
累加累专用传送指令
输入/输出指令
IN&&AL&，50H&
IN&&AX&，70H
OUT&&30H&&，AL
OUT&&80H&&，AX
IN&&AL&，DX&
IN&&AX&，DX
OUT&&DX&&，AL
OUT&&DX&&，AX
XLAT和XLATB指令将累加器中的一个值变换为内存表格中的某一个值，一般用来实现编码制的转换。
XLAT&&&类似于&&MOV&&&AL&&,&&DS:[BX&+AL]
XLATB&&类似于&&MOV&&&AL&&,&&DS:[EBX&+AL]&
地址传送指令
取地址有效指令
LEA&&AX，[2800]
LEA&&BX，[BP+SI]
LEA&&SP，[300H]
取段码和偏移量的指令LDS、LES、LSS、LFS、LGS
指令操作符中指出了段寄器名DS、ES、SS、FS和GS，随着寄存器的位数不同，传送的字节数也不同。
LDS&&DI，[2130H]
;把2130H和2131H中的16位偏移量送到DI，而把2132H
&&&&&&&&&&&&&&&&&&&&;和2133H中的16位段码送DS
标志传送指令
读取标志指令
LAHF&;将标志寄存器中的低8位传送到AH中
设置标志指令
SAHF&;将AH寄存器的内容传送到标志寄存器的低8位
对标志寄存器的推入和弹出堆栈指令（针对标志寄存器低16位）
对标志寄存器的推入和弹出堆栈指令（针对标志寄存器低32位）
算术运算指令
加法类指令
不带进位位的加法指令
ADD&&AX&，BX&;不考虑CF位
带进位位的加法指令
ADD&&AX&，BX&;将进位标志CF位的值加在和中
XADD指令实现两个功能：一是通过交换将目的操作数送入源操作数处，二是将源操作数和目的操作数相加再送目的操作数处。
如:&[AX]=1234H&&&&,[BX]&=&1111H
执行&XADD&&AX,BX后
[AX]=&&2345H
[BX]=&1234H
增量指令INC
减法类指令
不考虑借位的减法指令
SUB&&AX&，BX&;不考虑CF位
带借位的减法指令
SBB&&AX&，BX&;在运算时还要减去CF的值
减量指令DEC
CMP&&AL，20&;不送回相减的结果，只是使结果影响标志位
①　两个无符号数的比较，如果结果CF为0，则表示无借位，即被减数&=减数；如果结果CF为1，则表示有借位，即被减数&减数。
②　两个有符号数的比较，OF和CF符号相同，被减数&=减数；OF和CF符号不同，被减数&减数。
无符号数乘法指令MUL
MUL&CX&；AX中和CX中的两个16位数相乘，结果在DX和AX中
MUL&BYTE&PTR[DI]&;AL中和DI所指的单元中的两个8位数相乘，结果在AX中
有符号数乘法指令IMUL
无符号数除法指令DIV
DIV&CL&；AX中的数除以CL中的数，商在AL中，余数在AH中
DIV&WORD&PTR[DI]&;DX和AX中的32位数除以DI、DI+1所指单元中的16位数
&&&&&&&&&&&&&&&&&&;商在AX中，余数在DX中
有符号数除法指令IDIV
类型转换指令
CBW&;将AL寄存器的符号位扩展到AH中
CWD&;将AX寄存器的符号位扩展到DX中
CWDE&;将AX寄存器的符号位扩展到EAX中
CDQ&;将EAX寄存器的符号位扩展到EDX中
组合BCD码——用一个字节表示2位BCD码；
非组合BCD码——用一个字节的低4位表示1位BCD码，高4位为0；
AAA&;非组合BCD码用的加法调整指令
DAA&;组合BCD码用的加法调整指令
AAS&;非组合BCD码用的减法调整指令
DAS&;组合BCD码用的减法调整指令
AAM&;非组合BCD码用的乘法MUL指令的调整指令
AAD&;非组合BCD码用的除法DIV指令的调整指令
逻辑运算与移位指令
AND&&AX&，BX
OR&&&&&AL，CL
XOR&&AX，AX
TEST&&AL，20
非循环移位
①　算术左移/右移
SAL&&AX&，1
SAR&&AX&，CL
②　逻辑左移/右移
SHL&&WORD&PTR[DI]&，CL
SHR&&BYTE&PTR[DI]&，CL
①　不带CF的循环左移/右移
ROL&&AX，1
ROR&&WORD&PTR[DI]&，CL
②　带CF的循环左移/右移
RCL&&BX，CL
RCR&&BYTE&PTR[DI]&，CL
双精度移位
SHLD&&EAX，EBX,&3&;EAX左移3位，其“空出”的低位由EBX
&&&&&&&&&&&&&&&&&&&&;的高位3位来填补，源操作数不改变。
SHLD&&AL，BL,&CL
SHRD&&EAX&，EBX,&10&;EAX右移10位，其“空出”的高位由EBX
&&&&&&&&&&&&&&&&&&&&&&;的低10位来填补，源操作数不改变。
SHRD&&EAX&，EBX，CL
串操作指令
&因串指令本身没有带操作数，操作数是隐含的，故在使用时要做很多准备工作，包括：
源（读出）存储区首地址放入DS:SI；
目的（写入）存储区首地址放入ES:DI；
数据块长度放入CX；
设定DF标志。
字符串传送指令MOVSB/MOVSW（DS:SI放源地址,ES:DI放目的地址）
MOV&SI,1000H
MOV&DI,2000H
REP&&MOVSB
MOV&SI,1000H
MOV&DI,2000H
&&&&DEC&&CX
字符串比较指令CMPSB/CMPSW（把DS:SI所指向的内存中内容和ES:DI所指向的内存中内容做比较）
字符串检索指令SCASB/SCASW
取字符串指令&LODSB/LODSW/LODSD（把DS：SI所指向的内存的内容取到AL、AX或EAX中）
存字符串指令STOSB/STOSW/STOSD&（把AL、AX或EAX中内容存到ES:DI所指向的内存中）
REP、REPE/REPZ、REPNE/REPNZ指令
A）如果CX=0&，则退出REP，否则往下执行；
B）CX&=&CX&-1；
C）执行REP后面的串处理指令一次；
&D）重复&A）到C）
这条指令可以和MOVS、STOS、LODS一起使用。
II）REPE/REPZ
A）如果CX=0或ZF=0&则退出，否则往下执行；
B）CX&=&CX&-1；
C）执行REPE/REPZ后面的串处理指令一次；
D）重复&A）到C）
III）REPNE/REPNZ
A）如果CX=0或ZF=1&则退出，否则往下执行；
B）CX&=&CX&-1；
C）执行REPE/REPZ后面的串处理指令一次；
D）重复&A）到C）
REPE/REPZ、REPNE/REPNZ指令可以和CMPS、SCAS一起使用。
控制转移指令
无条件转移指令
JMP&&2000H
JMP&&DWORD&PTR[ST]
条件转移指令
I)&单个条件标志
A)&JZ(或JE)&&&如果ZF=1，则转移
B)&JNZ(或JNE)&&&如果ZF=0，则转移
C)&JS&&&如果SF=1，则转移
D)&JNS&&&如果SF=0，则转移
E)&JO&&&如果OF=1，则转移
F)&JNO&&&如果OF=0，则转移
G)&JP&&&如果PF=0，则转移
H)&JNP&&&如果OF=0，则转移
II）用于二个无符号数的比较
A）JB（JNAE、JC）&&&&A&B
B）JNB（JNE、JNC）&A&≥&B
C）JBE（JNA）&&&&&&&&&&&&A&≤&B
D）JNBE（JA）&&&&&&&&&&&&A&&B
III）用于二个有符号数的比较
A）JL（JNGE）&&&&&&&&&&&&A&B
B）JNL（JGE）&&&&&&&&&&&&A&≥&B
C）JLE（JNG）&&&&&&&&&&&&A&≤&B
D）JNLE（JG）&&&&&&&&&&&&A&&B
&&&&如果CX=0,则转移
循环控制指令
LOOP&;先将ECX或CX的内容减1，再判断是否为0，如果不为0，则继续循环。
LOOPZ/LOOPE&;先将ECX或CX的内容减1，ECX或CX不为0且ZF=1时继续循环
LOOPNZ/LOOPNE&;先将ECX或CX的内容减1，ECX或CX不为0且ZF=0时继续循环
中断指令和中断返回指令
子程序调用和返回指令
处理器控制指令
I)&暂停指令
II）标志操作指令
A）进位标志处理指令STC/CLC/CMC（求反）
B）方向标志设置和清除指令STD/CLD
C）中断允许标志设置和清除指令STI/CLI
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。