#include "REG52.H"

/* 注释一：
* 本系统中，规定最大运算位数是4位。
* 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
* 不能超过256个，如果超过了这个极限，编译器就会报错。如果这个算法
* 移植到stm32或者PIC等RAM比较大的单片机上，那么就可以把这个运算位数
* 设置得更加大一点。
*/

#define  BCD4_MAX     2  //本系统中，规定的组合BCD码最大字节数，一个字节包含2位，因此4位有效运算数
#define  BCD8_MAX    (BCD4_MAX*2)  //本系统中，规定的非组合BCD码最大字节数，一个字节包含1位，因此4位有效运算数

#define const_rc_size  30  //接收串口中断数据的缓冲区数组大小

#define const_receive_time  5  //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小

#define uchar unsigned char    //方便移植平台
#define ulong unsigned long   //方便移植平台

//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int
//#define ulong int

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 BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4, unsigned char ucBCD4_cnt, unsigned char *p_ucBCD_bit8, unsigned char *p_ucBCD8_cnt);
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8, unsigned char ucBCD8_cnt, unsigned char *p_ucBCD_bit4, unsigned char *p_ucBCD4_cnt);

void ClearAllData(uchar ucARRAY_MAX, uchar *destData);
uchar GetDataLength(const uchar *destData, uchar ucARRAY_MAX);
uchar AddData(const uchar *destData, const uchar *sourceData, uchar *resultData);

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; //用来解析数据协议的中间变量


unsigned char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式  这里是指被加数
unsigned char ucDataBCD4_cnt_1 = 0; //接收到的第1个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式  这里是指加数
unsigned char ucDataBCD4_cnt_2 = 0; //接收到的第2个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式  这里是指和
unsigned char ucDataBCD4_cnt_3 = 0; //接收到的第3个数组合BCD码数组的有效数据长度


unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式   这里是指被加数
unsigned char ucDataBCD8_cnt_1 = 0; //接收到的第1个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式   这里是指加数
unsigned char ucDataBCD8_cnt_2 = 0; //接收到的第2个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式   这里是指和
unsigned char ucDataBCD8_cnt_3 = 0; //接收到的第3个数非组合BCD码数组的有效数据长度

unsigned char ucResultFlag = 11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。

void main()
{
    initial_myself();
    delay_long(100);
    initial_peripheral();
    while(1)
    {
        usart_service();  //串口服务程序
    }

}

/* 注释二：
* 组合BCD码转成非组合BCD码。
* 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
* 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4, unsigned char ucBCD4_cnt, unsigned char *p_ucBCD_bit8, unsigned char *p_ucBCD8_cnt)
{
    unsigned char ucTmep;
    unsigned char i;

    for(i = 0; i < BCD8_MAX; i++) //先把即将保存转换结果的缓冲区清零
    {
        p_ucBCD_bit8[i] = 0;
    }


    *p_ucBCD8_cnt = ucBCD4_cnt * 2; //转换成非组合BCD码后的有效数据长度

    for(i = 0; i < ucBCD4_cnt; i++)
    {
        ucTmep = p_ucBCD_bit4[ucBCD4_cnt - 1 - i];
        p_ucBCD_bit8[ucBCD4_cnt * 2 - i * 2 - 1] = ucTmep >> 4;
        p_ucBCD_bit8[ucBCD4_cnt * 2 - i * 2 - 2] = ucTmep & 0x0f;
    }

}


/* 注释三：
* 非组合BCD码转成组合BCD码。
* 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
* 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8, unsigned char ucBCD8_cnt, unsigned char *p_ucBCD_bit4, unsigned char *p_ucBCD4_cnt)
{
    unsigned char ucTmep;
    unsigned char i;
    unsigned char ucBCD4_cnt;

    for(i = 0; i < BCD4_MAX; i++) //先把即将保存转换结果的缓冲区清零
    {
        p_ucBCD_bit4[i] = 0;
    }

    ucBCD4_cnt = (ucBCD8_cnt + 1) / 2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
    *p_ucBCD4_cnt = ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果

    for(i = 0; i < ucBCD4_cnt; i++)
    {
        ucTmep = p_ucBCD_bit8[ucBCD4_cnt * 2 - 1 - i * 2]; //把非组合BCD码第8位分解出来
        p_ucBCD_bit4[ucBCD4_cnt - 1 - i] = ucTmep << 4;
        p_ucBCD_bit4[ucBCD4_cnt - 1 - i] = p_ucBCD_bit4[ucBCD4_cnt - 1 - i] + p_ucBCD_bit8[ucBCD4_cnt * 2 - 2 - i * 2]; //把非组合BCD码第7位分解出来
    }

}

/* 注释四：
*函数介绍：清零数组的全部数组数据
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*输入输出参数：*destData--被清零的数组。
*/

void ClearAllData(uchar ucARRAY_MAX, uchar *destData)
{
    uchar i;

    for(i = 0; i < ucARRAY_MAX; i++)
    {
        destData[i] = 0;
    }

}


/* 注释五：
*函数介绍：获取数组的有效长度
*输入参数：*destData--被获取的数组。
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*返回值  ：返回数组的有效长度。比如58786这个数据的有效长度是5
*电子开发者作者：吴坚鸿
*/
uchar GetDataLength(const uchar *destData, uchar ucARRAY_MAX)
{
    uchar i;
    uchar DataLength = ucARRAY_MAX;
    for(i = 0; i < ucARRAY_MAX; i++)
    {
        if(0 != destData[ucARRAY_MAX - 1 - i])
        {
            break;
        }
        else
        {
            DataLength--;
        }

    }

    return DataLength;

}



/* 注释六：
*函数介绍：两个数相加
*输入参数：
*（1）*destData--被加数的数组。
*（2）*sourceData--加数的数组。
*（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar AddData(const uchar *destData, const uchar *sourceData, uchar *resultData)
{
    uchar addResult = 11; //开始默认返回的运算结果是正常
    uchar destCnt = 0;
    uchar sourceCnt = 0;
    uchar i;
    uchar carryData = 0; //进位
    uchar maxCnt = 0; //最大位数
    uchar resultTemp = 0; //存放临时运算结果的中间变量

    //为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
    //因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。

    destCnt = GetDataLength(destData, BCD8_MAX); //获取被加数的有效位数
    sourceCnt = GetDataLength(sourceData, BCD8_MAX); //获取加数的有效位数

    if(destCnt >= sourceCnt) //找出两个运算数据中最大的有效位数
    {
        maxCnt = destCnt;
    }
    else
    {
        maxCnt = sourceCnt;
    }

    for(i = 0; i < maxCnt; i++)
    {
        resultTemp = destData[i] + sourceData[i] + carryData; //按位相加
        resultData[i] = resultTemp % 10; //截取最低位存放进保存结果的数组
        carryData = resultTemp / 10; //存放进位
    }

    resultData[i] = carryData;

    if((maxCnt == BCD8_MAX) && (carryData == 1)) //如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
    {

        ClearAllData(BCD8_MAX, resultData);

        addResult = 10; //报错
    }


    return addResult;
}




void usart_service(void)  //串口服务程序,在main函数里
{

    unsigned char i = 0;
    unsigned char k = 0;
    unsigned char ucGetDataStep = 0;

    if(uiSendCnt >= const_receive_time && ucSendLock == 1) //说明超过了一定的时间内，再也没有新数据从串口来
    {

        ucSendLock = 0;  //处理一次就锁起来，不用每次都进来,除非有新接收的数据

        //下面的代码进入数据协议解析和数据处理的阶段

        uiRcMoveIndex = 0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
        while(uiRcMoveIndex < uiRcregTotal) //说明还没有把缓冲区的数据读取完
        {
            if(ucRcregBuf[uiRcMoveIndex + 0] == 0xeb && ucRcregBuf[uiRcMoveIndex + 1] == 0x00 && ucRcregBuf[uiRcMoveIndex + 2] == 0x55) //数据头eb 00 55的判断
            {

                i = 0;
                ucGetDataStep = 0;
                ucDataBCD4_cnt_1 = 0; //第1个数组合BCD码数组的有效数据长度
                ucDataBCD4_cnt_2 = 0; //第2个数组合BCD码数组的有效数据长度

                ClearAllData(BCD4_MAX, ucDataBCD4_1); //清零第1个参与运算的数据
                ClearAllData(BCD4_MAX, ucDataBCD4_2); //清零第2个参与运算的数据

                //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
                while(i < (BCD8_MAX + 4)) //这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
                {
                    if(ucGetDataStep == 0) //步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被加数
                    {
                        if(ucRcregBuf[uiRcMoveIndex + 3 + i] == 0x0d && ucRcregBuf[uiRcMoveIndex + 4 + i] == 0x0a) //结束标志
                        {
                            for(k = 0; k < ucDataBCD4_cnt_1; k++) //提取第1个参与运算的数组数据
                            {
                                ucDataBCD4_1[k] = ucRcregBuf[uiRcMoveIndex + 3 + i - 1 - k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
                            }

                            i = i + 2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
                            ucGetDataStep = 1; //切换到下一个关键字提取的步骤

                        }
                        else
                        {
                            i++;
                            ucDataBCD4_cnt_1++;  //统计第1个有效数据的长度
                        }

                    }
                    else if(ucGetDataStep == 1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是加数
                    {
                        if(ucRcregBuf[uiRcMoveIndex + 3 + i] == 0x0d && ucRcregBuf[uiRcMoveIndex + 4 + i] == 0x0a) //结束标志
                        {
                            for(k = 0; k < ucDataBCD4_cnt_2; k++) //提取第2个参与运算的数组数据
                            {
                                ucDataBCD4_2[k] = ucRcregBuf[uiRcMoveIndex + 3 + i - 1 - k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
                            }

                            break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环

                        }
                        else
                        {
                            i++;
                            ucDataBCD4_cnt_2++;  //统计第2个有效数据的长度
                        }
                    }
                }


                //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
                BCD4_to_BCD8(ucDataBCD4_1, ucDataBCD4_cnt_1, ucDataBCD8_1, &ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码  第1个数
                BCD4_to_BCD8(ucDataBCD4_2, ucDataBCD4_cnt_2, ucDataBCD8_2, &ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码  第2个数


                ClearAllData(BCD8_MAX, ucDataBCD8_3); //清零第3个参与运算的数据,用来接收运行的结果
                ucResultFlag = AddData(ucDataBCD8_1, ucDataBCD8_2, ucDataBCD8_3); //相加运算，结果放在ucDataBCD8_3数组里

                if(ucResultFlag == 11) //表示运算结果没有超范围
                {
                    ucDataBCD8_cnt_3 = GetDataLength(ucDataBCD8_3, BCD8_MAX); //获取和的有效字节数
                    BCD8_to_BCD4(ucDataBCD8_3, ucDataBCD8_cnt_3, ucDataBCD4_3, &ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
                    for(k = 0; k < ucDataBCD4_cnt_3; k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
                    {
                        eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3 - 1 - k]); //往上位机发送一个字节的函数
                    }
                }
                else //运算结果超范围，返回EE EE EE
                {
                    eusart_send(0xee); //往上位机发送一个字节的函数
                    eusart_send(0xee); //往上位机发送一个字节的函数
                    eusart_send(0xee); //往上位机发送一个字节的函数
                }

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

        ucRcregBuf[0] = 0; //把数据头清零，方便下次接收判断新数据
        ucRcregBuf[1] = 0;
        ucRcregBuf[2] = 0;

        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;  //启动定时中断

}