单片机学习笔记————指针的第二大好处，指针作为数组在函数中的输入接口

proteus虚拟串口的实现：https://mp.csdn.net/console/editor/html/107251649

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

​

 

二、编写程序

/********************************************************************************************************************
----    @Project:    Pointer
----    @File:    main.c
----    @Edit:    ZHQ
----    @Version:    V1.0
----    @CreationTime:    20200808
----    @ModifiedTime:    20200808
----    @Description:    
----    波特率是：9600 。
----    通讯协议：EB 00 55  XX YY  
----    把5个随机数据按从大到小排序，用冒泡法来排序。
----    通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07  指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第1种方法的排序结果，中间3个数据EE EE EE是第1种和第2种的分割线，为了方便观察，没实际意义。最后5个数据是第2种方法的排序结果.
----    
----    比如电脑发送：EB 00 55 08 06 09 05 07
----    单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05 
----    单片机：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_array_size  5  /* 参与排序的数组大小 */

#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 ucUsartBuffer[const_array_size];    /* 从串口接收到的需要排序的原始数据 */
unsigned char ucGlobalBuffer_1[const_array_size];    /* 第1种方法，参与具体排序算法的全局变量数组 */
unsigned char ucGlobalBuffer_2[const_array_size];    /* 第2种方法，参与具体排序算法的全局变量数组 */

/**
* @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<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  /*内嵌循环的空指令数量*/
          {
             ; /*一个分号相当于执行一条空语句*/
          }
   }
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Short(unsigned int uiDelayShort)
{
  unsigned int i;
  for(i=0;i<uiDelayShort;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种方法，用不带输入输出接口的空函数，这是最原始的做法，它完全依靠
* 全局变量作为函数的输入和输出口。我们要用到这个函数，就要把参与运算
* 的变量直接赋给对应的输入全局变量，调用一次函数之后，再找到对应的
* 输出全局变量，这些输出全局变量就是我们要的结果。
* 在本函数中，ucGlobalBuffer_1[const_array_size]既是输入全局变量，也是输出全局变量，
* 这种方法的缺点是阅读不直观，封装性不强，没有面对用户的输入输出接口，
**/
void big_to_small_sort_1(void)    /* 第1种方法 把一个数组从大小小排序 */
{
    unsigned char i;
    unsigned char k;
    unsigned char ucTemp;    /* 在两两交换数据的过程中，用于临时存放交换的某个变量 */

    /* 冒泡法 */
    for(i = 0; i < (const_array_size - 1); i ++)    /* 冒泡的次数是(const_array_size-1)次 */
    {
        for(k = 0; k < (const_array_size - 1 - i); k ++)
        {
            if(ucGlobalBuffer_1[const_array_size - 1 - k] > ucGlobalBuffer_1[const_array_size - 1 - 1 - k])
            {
                ucTemp = ucGlobalBuffer_1[const_array_size - 1 - 1 - k];
                ucGlobalBuffer_1[const_array_size - 1 - 1 - k] = ucGlobalBuffer_1[const_array_size  - 1 - k];
                ucGlobalBuffer_1[const_array_size  - 1 - k] = ucTemp;
            }
        }
    }
}

/**
* @brief  第2种方法
* @param  无
* @retval 
* 第2种方法，为了改进第1种方法的用户体验，用指针为函数增加一个输入接口。
* 为什么要用指针？因为C语言的函数中，数组不能直接用来做函数的形参，只能用指针作为数组的形参。
* 比如，你不能这样写一个函数void big_to_small_sort_2(unsigned char a[5])，否则编译就会出错不通过。
* 在本函数中，*p_ucInputBuffer指针就是输入接口，而输出接口仍然是全局变量数组ucGlobalBuffer_2。
* 这种方法由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了。
**/
void big_to_small_sort_2(unsigned char *p_ucInputBuffer)
{
    unsigned char i;
    unsigned char k;
    unsigned char ucTemp;    /* 在两两交换数据的过程中，用于临时存放交换的某个变量 */

    for(i = 0; i < const_array_size; i ++)    /* 参与排序算法之前，先把输入接口的数据全部搬移到全局变量数组中。 */
    {
        ucGlobalBuffer_2[i] = p_ucInputBuffer[i];
    }

    /* 冒泡法 */
    for(i = 0; i < (const_array_size - 1); i ++)    /* 冒泡的次数是(const_array_size-1)次 */
    {
        for(k = 0; k < (const_array_size - 1 - i); k ++)
        {
            if(ucGlobalBuffer_2[const_array_size - 1 - k] > ucGlobalBuffer_2[const_array_size - 1 - 1 - k])
            {
                ucTemp = ucGlobalBuffer_2[const_array_size - 1 - 1 - k];
                ucGlobalBuffer_2[const_array_size - 1 - 1 - k] = ucGlobalBuffer_2[const_array_size  - 1 - k];
                ucGlobalBuffer_2[const_array_size  - 1 - k] = ucTemp;
            }
        }
    }
}

/**
* @brief  串口服务程序
* @param  无
* @retval 
* 以下函数说明了，在空函数里，可以插入很多个return语句。
* 用return语句非常便于后续程序的升级修改。
**/
void usart_service(void)
{
    unsigned char i = 0;
    // /*如果超过了一定的时间内，再也没有新数据从串口来*/
    // 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)
        {
            for(i = 0; i < const_array_size; i ++)    /* 从串口接收到的需要被排序的原始数据 */
            {
                ucUsartBuffer[i] = ucRcregBuf[uiRcMoveIndex+3+i];
            }
            /* 第1种运算方法，依靠全局变量 */
            for(i = 0; i < const_array_size; i ++)    /* 把需要被排列的数据放进输入全局变量数组 */
            {
                ucGlobalBuffer_1[i] = ucUsartBuffer[i];
            }
            big_to_small_sort_1();    /* 调用一次空函数就出结果了，结果还是保存在ucGlobalBuffer_1全局变量数组中 */
            for(i = 0; i < const_array_size; i ++)
            {
                eusart_send(ucGlobalBuffer_1[i]);    /* 把用第1种方法排序后的结果返回给上位机观察 */    
            }

            /* 为了方便上位机观察，多发送3个字节ee ee ee作为第1种方法与第2种方法的分割线 */
            eusart_send(0xee);
            eusart_send(0xee);
            eusart_send(0xee);


            /* 第2种运算方法，依靠指针为函数增加一个数组的输入接口 */
            /* 通过指针输入接口，直接把ucUsartBuffer数组的首地址传址进去，排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中 */                
            big_to_small_sort_2(ucUsartBuffer);
            for(i = 0; i < const_array_size; i ++)
            {
                eusart_send(ucGlobalBuffer_2[i]);    /* 把用第2种方法排序后的结果返回给上位机观察 */    
            }            

            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();
    }
}

 

三、仿真实现

​