指针的第一大好处，让一个函数可以封装多个相当于return语句返回的参数

一、使用proteus绘制简单的电路图，用于后续仿真

二、编写程序

/********************************************************************************************************************

---- @Project: Pointer

---- @File: main.c

---- @Edit: ZHQ

---- @Version: V1.0

---- @CreationTime: 20200808

---- @ModifiedTime: 20200808

---- @Description:

---- 波特率是：9600 。

---- 通讯协议：EB 00 55  XX YY  

---- 通过电脑串口调试助手，往单片机发送EB 00 55 XX YY  指令，其中EB 00 55是数据头， XX是被除数，YY是除数。单片机收到指令后就会返回6个数据，最前面两个数据是第1种运算方式的商和余数，中间两个数据是第2种运算方式的商和余数，最后两个数据是第3种运算方式的商和余数。

---- 比如电脑发送：EB 00 55 08 02

---- 单片机就返回：04 00 04 00 04 00  (04是商，00是余数)

---- 单片机：AT89C52

********************************************************************************************************************/

#include 'reg52.h'

/*——————宏定义——————*/

#define FOSC 11059200L

#define BAUD 9600

#define T1MS (65536-FOSC/12/500)   /*0.5ms timer calculation method in 12Tmode*/

#define const_voice_short 19 /*蜂鸣器短叫的持续时间*/

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

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

/*——————变量函数定义及声明——————*/

/*蜂鸣器的驱动IO口*/

sbit BEEP = P2^7;

/*LED*/

sbit LED = P3^5;

unsigned int uiSendCnt = 0; /*用来识别串口是否接收完一串数据的计时器*/

unsigned char ucSendLock = 1; /*串口服务程序的自锁变量，每次接收完一串数据只处理一次*/

unsigned int uiRcregTotal = 0; /*代表当前缓冲区已经接收了多少个数据*/

unsigned char ucRcregBuf[const_rc_size]; /*接收串口中断数据的缓冲区数组*/

unsigned int uiRcMoveIndex = 0; /*用来解析数据协议的中间变量*/

unsigned int uiVoiceCnt = 0; /*蜂鸣器鸣叫的持续时间计数器*/

unsigned char ucBeiChuShu_1 = 0; /* 第1种方法中的被除数 */

unsigned char ucChuShu_1 = 1; /* 第1种方法中的除数 */

unsigned char ucShang_1 = 0; /* 第1种方法中的商 */

unsigned char ucYu_1 = 0; /* 第1种方法中的余数 */

unsigned char ucBeiChuShu_2 = 0; /* 第2种方法中的被除数 */

unsigned char ucChuShu_2 = 1; /* 第2种方法中的除数 */

unsigned char ucShang_2 = 0; /* 第2种方法中的商 */

unsigned char ucYu_2 = 0; /* 第2种方法中的余数 */

unsigned char ucBeiChuShu_3 = 0; /* 第3种方法中的被除数 */

unsigned char ucChuShu_3 = 1; /* 第3种方法中的除数 */

unsigned char ucShang_3 = 0; /* 第3种方法中的商 */

unsigned char ucYu_3 = 0; /* 第3种方法中的余数 */

/**

* @brief  定时器0初始化函数

* @param  无

* @retval 初始化T0

**/

void Init_T0(void)

{

TMOD = 0x01;                    /*set timer0 as mode1 (16-bit)*/

TL0 = T1MS;                     /*initial timer0 low byte*/

TH0 = T1MS >> 8;                /*initial timer0 high byte*/

}

/**

* @brief  串口初始化函数

* @param  无

* @retval 初始化T0

**/

void Init_USART(void)

{

SCON = 0x50;

TMOD = 0x21;                    

TH1=TL1=-(FOSC/12/32/BAUD);

}

/**

* @brief  外围初始化函数

* @param  无

* @retval 初始化外围

* 让数码管显示的内容转移到以下几个变量接口上，方便以后编写更上一层的窗口程序。

* 只要更改以下对应变量的内容，就可以显示你想显示的数字。

**/

void Init_Peripheral(void)

{

ET0 = 1;/*允许定时中断*/

TR0 = 1;/*启动定时中断*/

TR1 = 1;

ES = 1; /*允许串口中断*/

EA = 1;/*开总中断*/  

}

/**

* @brief  初始化函数

* @param  无

* @retval 初始化单片机

**/

void Init(void)

{

LED  = 0;

Init_T0();

Init_USART();

}

/**

* @brief  延时函数

* @param  无

* @retval 无

**/

void Delay_Long(unsigned int uiDelayLong)

{

   unsigned int i;

   unsigned int j;

   for(i=0;i   {

      for(j=0;j<500;j++)  /*内嵌循环的空指令数量*/

          {

             ; /*一个分号相当于执行一条空语句*/

          }

   }

}

/**

* @brief  延时函数

* @param  无

* @retval 无

**/

void Delay_Short(unsigned int uiDelayShort)

{

  unsigned int i;

  for(i=0;i  {

; /*一个分号相当于执行一条空语句*/

  }

}

/**

* @brief  串口发送函数

* @param  unsigned char ucSendData

* @retval 往上位机发送一个字节的函数

**/

void eusart_send(unsigned char ucSendData)

{

ES = 0; /* 关串口中断 */

TI = 0; /* 清零串口发送完成中断请求标志 */

SBUF = ucSendData; /* 发送一个字节 */

Delay_Short(400); /* 每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整 */

TI = 0; /* 清零串口发送完成中断请求标志 */

ES = 1; /* 允许串口中断 */

}

/**

* @brief  第1种方法

* @param  无

* @retval 

*  第1种方法，用不带参数返回的空函数，这是最原始的做法，也是我当年刚毕业

* 就开始做项目的时候经常用的方法。它完全依靠全局变量作为函数的输入和输出口。

* 我们要用到这个函数，就要把参与运算的变量直接赋给对应的输入全局变量，

* 调用一次函数之后，再找到对应的输出变量，这些输出变量就是我们要的结果。

* 在本函数中，被除数ucBeiChuShu_1和除数ucChuShu_1就是输入全局变量，

* 商ucShang_1和余数ucYu_1就是输出全局变量。这种方法的缺点是阅读不直观，

* 封装性不强，没有面对用户的输入输出接口，

**/

void chu_fa_yun_suan_1(void) /* 第1种方法 求商和余数 */

{

if(ucChuShu_1 == 0) /* 如果除数为0，则商和余数都为0 */

{

ucShang_1 = 0;

ucYu_1 = 0;

}

else

{

ucShang_1 = (ucBeiChuShu_1) / (ucChuShu_1); /* 求商 */

ucYu_1 = (ucBeiChuShu_1) % (ucChuShu_1); /* 求余数 */

}

}

/**

* @brief  第2种方法

* @param  无

* @retval 

* 第2种方法，用return返回参数和带输入形参的函数，这种方法已经具备了完整的输入和输出性能，

* 比第1种方法直观多了。但是这种方法有它的局限性，因为return只能返回一个变量，

* 如果要用在返回多个输出结果的函数中，就无能为力了。比如本程序，就不能同时输出

* 商和余数，只能分两个函数来做。如果要在一个函数中同时输出商和余数，该怎么办？

* 这个时候就必须用指针了，也就是我下面讲到的第3种方法。

**/

unsigned char get_shang_2(unsigned char ucBeiChuShuTemp, unsigned char ucChuShuTemp)

{

unsigned char ucShangTemp;

if(ucChuShuTemp == 0) /* 如果除数为0，则商为0 */

{

ucShangTemp = 0;

}

else

{

ucShangTemp = (ucBeiChuShuTemp) / (ucChuShuTemp);

}

return ucShangTemp; /* 返回运算后的结果 商 */

}

unsigned char get_yu_2(unsigned char ucBeiChuShuTemp, unsigned char ucChuShuTemp)

{

unsigned char ucYuTemp;

if(ucChuShuTemp == 0) /* 如果除数为0，则余数为0 */

{

ucYuTemp = 0;

}

else

{

ucYuTemp = (ucBeiChuShuTemp) % (ucChuShuTemp);

}

return ucYuTemp; /* 返回运算后的结果 余数 */

}

/**

* @brief  第3种方法

* @param  无

* @retval 

* 第3种方法，用带指针的函数，就可以顺心所欲，不受return的局限，想输出多少个

* 运算结果都可以，赞一个！在本函数中，ucBeiChuShuTemp和ucChuShuTemp是输入变量，

* 它们不是指针，所以不具备输出接口属性。*p_ucShangTemp和*p_ucYuTemp是输出变量，

* 因为它们是指针，所以具备输出接口属性。

**/

void chu_fa_yun_suan_3(unsigned char ucBeiChuShuTemp, unsigned char ucChuShuTemp, unsigned char *p_ucShangTemp, unsigned char *p_ucYuTemp)

{

if(ucChuShuTemp == 0) /* 如果除数为0，则商和余数都为0 */

{

*p_ucShangTemp = 0;

*p_ucYuTemp = 0;

}

else

{

*p_ucShangTemp = (ucBeiChuShuTemp) / (ucChuShuTemp);

*p_ucYuTemp = (ucBeiChuShuTemp) % (ucChuShuTemp);

}

}

/**

* @brief  串口服务程序

* @param  无

* @retval 

* 以下函数说明了，在空函数里，可以插入很多个return语句。

* 用return语句非常便于后续程序的升级修改。

**/

void usart_service(void)

{

// /*如果超过了一定的时间内，再也没有新数据从串口来*/

// if(uiSendCnt >= const_receive_time && ucSendLock == 1)

// {

// 原来的语句，现在被两个return语句替代了

if(uiSendCnt < const_receive_time) /* 延时还没超过规定时间，直接退出本程序，不执行return后的任何语句。 */

{

return; /* 强行退出本子程序，不执行以下任何语句 */

}

if(ucSendLock == 0) /* 不是最新一次接收到串口数据，直接退出本程序，不执行return后的任何语句。 */

{

return; /* 强行退出本子程序，不执行以下任何语句 */

}

/*

 * 以上两条return语句就相当于原来的一条if(uiSendCnt>=const_receive_time&&ucSendLock==1)语句。

 * 用了return语句后，就明显减少了一个if嵌套。

 */

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

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

uiRcMoveIndex = 0; /*由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动*/

// /*

// * 判断数据头，进入循环解析数据协议必须满足两个条件:

// * 第一：最大接收缓冲数据必须大于一串数据的长度（这里是5。包括2个有效数据，3个数据头）

// * 第二：游标uiRcMoveIndex必须小于等于最大接收缓冲数据减去一串数据的长度（这里是5。包括2个有效数据，3个数据头）

// */

// while(uiRcregTotal >= 5 && uiRcMoveIndex <= (uiRcregTotal - 5))

// {

// 原来的语句，现在被两个return语句替代了

while(1) /* 死循环可以被以下return或者break语句中断，return本身已经包含了break语句功能。 */

{

if(uiRcregTotal < 5) /* 串口接收到的数据太少 */

{

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

return; /* 强行退出while(1)循环嵌套，直接退出本程序，不执行以下任何语句 */

}

if(uiRcMoveIndex > (uiRcregTotal - 5)) /* 数组缓冲区的数据已经处理完 */

{

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

return; /* 强行退出while(1)循环嵌套，直接退出本程序，不执行以下任何语句 */

}

/* 

 * 以上两条return语句就相当于原来的一条while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))语句。

 * 以上两个return语句的用法，同时说明了return本身已经包含了break语句功能,不管当前处于几层的内部循环嵌套，

 * 都可以强行退出循环，并且直接退出本程序。

 */

if(ucRcregBuf[uiRcMoveIndex + 0] == 0xeb && ucRcregBuf[uiRcMoveIndex + 1] == 0x00 && ucRcregBuf[uiRcMoveIndex + 2] == 0x55)

{

/* 第1种运算方法，依靠全局变量 */

ucBeiChuShu_1 = ucRcregBuf[uiRcMoveIndex + 3];

ucChuShu_1 = ucRcregBuf[uiRcMoveIndex + 4];

chu_fa_yun_suan_1();

eusart_send(ucShang_1);

eusart_send(ucYu_1);

/* 第2种运算方法，依靠两个带return语句的返回函数 */

ucBeiChuShu_2 = ucRcregBuf[uiRcMoveIndex + 3];

ucChuShu_2 = ucRcregBuf[uiRcMoveIndex + 4];

ucShang_2 = get_shang_2(ucBeiChuShu_2, ucChuShu_2);

ucYu_2 = get_yu_2(ucBeiChuShu_2, ucChuShu_2);

eusart_send(ucShang_2);

eusart_send(ucYu_2);

/* 第3种运算方法，依靠指针 */

ucBeiChuShu_3 = ucRcregBuf[uiRcMoveIndex + 3];

ucChuShu_3 = ucRcregBuf[uiRcMoveIndex + 4];

/*

* 注意，由于商和余数是指针形参，我们代入的变量必须带地址符号& 。比如&ucShang_3和&ucYu_3。

* 因为我们是把变量的地址传递进去的。

*/

chu_fa_yun_suan_3(ucBeiChuShu_3, ucChuShu_3, &ucShang_3, &ucYu_3);

eusart_send(ucShang_3);

eusart_send(ucYu_3);

break; /*退出while(1)循环*/

}

uiRcMoveIndex ++; /*因为是判断数据头，游标向着数组最尾端的方向移动*/

}

// }

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

// }

}

/**

* @brief  定时器0中断函数

* @param  无

* @retval 无

**/

void ISR_T0(void) interrupt 1

{

TF0 = 0;  /*清除中断标志*/

TR0 = 0; /*关中断*/

if(uiSendCnt < const_receive_time) /*如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完*/

{

uiSendCnt ++; /*表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来*/

ucSendLock = 1; /*开自锁标志*/

}

if(uiVoiceCnt != 0)

{

uiVoiceCnt --;

BEEP = 0;

}

else

{

;

BEEP = 1;

}

TL0 = T1MS;                     /*initial timer0 low byte*/

TH0 = T1MS >> 8;                /*initial timer0 high byte*/

  TR0 = 1; /*开中断*/

}

/**

* @brief  串口接收数据中断

* @param  无

* @retval 无

**/

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;

}

}

/*————————————主函数————————————*/

/**

* @brief  主函数

* @param  无

* @retval 实现LED灯闪烁

**/

void main()

{

/*单片机初始化*/

Init();

/*延时，延时时间一般是0.3秒到2秒之间，等待外围芯片和模块上电稳定*/

Delay_Long(100);

/*单片机外围初始化*/

Init_Peripheral();

while(1)

{

usart_service();

}

}

三、仿真实现

指针的第一大好处，让一个函数可以封装多个相当于return语句返回的参数