第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系。

开场白：

本来这一节打算讲大数据的加法运算的，但是考虑大数据运算的基础是非组合BCD码，所以多增加一节讲BCD码的内容。

计算机中的BCD码，经常使用的有两种格式，即组合BCD码，非组合BCD码。

组合BCD码，是将两位十进制数，存放在一个字节中，例如：十进制数51的存放格式是0101 0001。

非组合BCD码，是将一个字节的低四位编码表示十进制数的一位，而高4位都为0。例如：十进制数51的占用了两个字节的空间，存放格式为：00000101 00000001。

这一节要教大家两个知识点：

第一个：如何编写组合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是分割线，为了方便观察，没实际意义。
- 例如：十进制的数据52013140，它的十六进制数据是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至99999999
* 数组中的数据。高位在数组下标大的方向，低位在数组下标小的方向。
*/
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();
    while(1)
    {
        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 % 100000000 / 10000000;
    p_ucBCD_bit4[3] = p_ucBCD_bit4[3] << 4; //前半4位存第8位组合BCD码
    ucTemp = ulNumberTemp % 10000000 / 1000000;
    p_ucBCD_bit4[3] = p_ucBCD_bit4[3] + ucTemp; //后半4位存第7位组合BCD码

    p_ucBCD_bit4[2] = ulNumberTemp % 1000000 / 100000;
    p_ucBCD_bit4[2] = p_ucBCD_bit4[2] << 4; //前半4位存第6位组合BCD码
    ucTemp = ulNumberTemp % 100000 / 10000;
    p_ucBCD_bit4[2] = p_ucBCD_bit4[2] + ucTemp; //后半4位存第5位组合BCD码

    p_ucBCD_bit4[1] = ulNumberTemp % 10000 / 1000;
    p_ucBCD_bit4[1] = p_ucBCD_bit4[1] << 4; //前半4位存第4位组合BCD码
    ucTemp = ulNumberTemp % 1000 / 100;
    p_ucBCD_bit4[1] = p_ucBCD_bit4[1] + ucTemp; //后半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] + ucTemp; //后半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 % 100000000 / 10000000; //一个字节8位存储第8位非组合BCD码
    p_ucBCD_bit8[6] = ulNumberTemp % 10000000 / 1000000; //一个字节8位存储第7位非组合BCD码
    p_ucBCD_bit8[5] = ulNumberTemp % 1000000 / 100000; //一个字节8位存储第6位非组合BCD码
    p_ucBCD_bit8[4] = ulNumberTemp % 100000 / 10000; //一个字节8位存储第5位非组合BCD码
    p_ucBCD_bit8[3] = ulNumberTemp % 10000 / 1000; //一个字节8位存储第4位非组合BCD码
    p_ucBCD_bit8[2] = ulNumberTemp % 1000 / 100; //一个字节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 ulTmep;
    unsigned long ulSum;

    ulSum = 0; //累加和数值清零

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[3];
    ulTmep = ulTmep >> 4; //把组合BCD码第8位分解出来
    ulTmep = ulTmep * 10000000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[3];
    ulTmep = ulTmep & 0x0000000f; //把组合BCD码第7位分解出来
    ulTmep = ulTmep * 1000000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[2];
    ulTmep = ulTmep >> 4; //把组合BCD码第6位分解出来
    ulTmep = ulTmep * 100000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[2];
    ulTmep = ulTmep & 0x0000000f; //把组合BCD码第5位分解出来
    ulTmep = ulTmep * 10000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[1];
    ulTmep = ulTmep >> 4; //把组合BCD码第4位分解出来
    ulTmep = ulTmep * 1000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[1];
    ulTmep = ulTmep & 0x0000000f; //把组合BCD码第3位分解出来
    ulTmep = ulTmep * 100;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[0];
    ulTmep = ulTmep >> 4; //把组合BCD码第2位分解出来
    ulTmep = ulTmep * 10;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit4[0];
    ulTmep = ulTmep & 0x0000000f; //把组合BCD码第1位分解出来
    ulTmep = ulTmep * 1;
    ulSum = ulSum + ulTmep; //累加各位数值

    //以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。

    p_ucNumber[3] = ulSum >> 24; //把long类型数据分解成4个字节
    p_ucNumber[2] = ulSum >> 16;
    p_ucNumber[1] = ulSum >> 8;
    p_ucNumber[0] = ulSum;
}



void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4, unsigned char *p_ucBCD_bit8) //组合BCD码转成非组合BCD码
{
    unsigned char ucTmep;

    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 ulTmep;
    unsigned long ulSum;

    ulSum = 0; //累加和数值清零

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[7];
    ulTmep = ulTmep * 10000000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[6];
    ulTmep = ulTmep * 1000000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[5];
    ulTmep = ulTmep * 100000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[4];
    ulTmep = ulTmep * 10000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[3];
    ulTmep = ulTmep * 1000;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[2];
    ulTmep = ulTmep * 100;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[1];
    ulTmep = ulTmep * 10;
    ulSum = ulSum + ulTmep; //累加各位数值

    ulTmep = 0;
    ulTmep = p_ucBCD_bit8[0];
    ulTmep = ulTmep * 1;
    ulSum = ulSum + ulTmep; //累加各位数值

    //以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。

    p_ucNumber[3] = ulSum >> 24; //把long类型数据分解成4个字节
    p_ucNumber[2] = ulSum >> 16;
    p_ucNumber[1] = ulSum >> 8;
    p_ucNumber[0] = ulSum;
}



void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8, unsigned char *p_ucBCD_bit4) //非组合BCD码转成组合BCD码
{
    unsigned char ucTmep;

    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码返回给上位机观察，注意，高位在数组下标大的方向
                    }

                    break;
                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码返回给上位机观察，注意，高位在数组下标大的方向
                    }

                    break;
                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码返回给上位机观察，注意，高位在数组下标大的方向
                    }

                    break;
                }

                break;   //退出循环
            }
            uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
        }

        uiRcregTotal = 0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据

    }

}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

    ES = 0; //关串口中断
    TI = 0; //清零串口发送完成中断请求标志
    SBUF = ucSendData; //发送一个字节

    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 = 0xfe; //重装初始值(65535-500)=65035=0xfe0b
    TL0 = 0x0b;
    TR0 = 1; //开中断
}


void usart_receive(void) interrupt 4                 //串口接收数据中断
{

    if(RI == 1)
    {
        RI = 0;

        ++uiRcregTotal;
        if(uiRcregTotal > const_rc_size) //超过缓冲区
        {
            uiRcregTotal = const_rc_size;
        }
        ucRcregBuf[uiRcregTotal - 1] = SBUF; //将串口接收到的数据缓存到接收缓冲区里
        uiSendCnt = 0; //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。

    }
    else  //发送中断，及时把发送中断标志位清零
    {
        TI = 0;
    }

}


void delay_long(unsigned int uiDelayLong)
{
    unsigned int i;
    unsigned int j;
    for(i = 0; i < uiDelayLong; i++)
    {
        for(j = 0; j < 500; j++) //内嵌循环的空指令数量
        {
            ; //一个分号相当于执行一条空语句
        }
    }
}

void delay_short(unsigned int uiDelayShort)
{
    unsigned int i;
    for(i = 0; i < uiDelayShort; i++)
    {
        ;   //一个分号相当于执行一条空语句
    }
}


void initial_myself(void)  //第一区 初始化单片机
{

    beep_dr = 1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

    //配置定时器
    TMOD = 0x01; //设置定时器0为工作方式1
    TH0 = 0xfe; //重装初始值(65535-500)=65035=0xfe0b
    TL0 = 0x0b;


    //配置串口
    SCON = 0x50;
    TMOD = 0X21;
    TH1 = TL1 = -(11059200L / 12 / 32 / 9600); //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
    TR1 = 1;

}

void initial_peripheral(void) //第二区 初始化外围
{

    EA = 1;   //开总中断
    ES = 1;   //允许串口中断
    ET0 = 1;  //允许定时中断
    TR0 = 1;  //启动定时中断

}

总结陈词：

有了这一节非组合BCD的基础知识，下一节就开始讲大数据的算法程序。这些算法程序经常要用在计算器，工控，以及高精度的仪器仪表等领域。C语言的语法中不是已经提供了+,-,*,/这些运算符号吗？为什么还要专门写算法程序？因为那些运算符只能进行简单的运算，一旦数据超过了unsigned long（4个字节）的范围就会出错。而这种大数据算法的程序是什么样的？欲知详情，请听下回分解----大数据的加法运算。

（未完待续，下节更精彩，不要走开哦）

61. 组合BCD码_非组合BCD码_以及数值三者之间的相互转换和关系

第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系。

results matching ""

No results matching ""