开场白：
单个变量数据之间能够通过一条指令恣意自在赋值搬运，可是数组之间不能通过一条指令直接赋值搬运，必须用for等循环指令挨个把数组的数据一个一个来赋值搬运，假如一个 函数中，有许多数组需求赋值搬运，那就十分麻烦了，要用许多for句子，耗时。还好C言语里有个指针，它能够十分高效地来切换咱们所需求的数组，起到很好的中转站效果。这一节要教我们一个常识点：指针在很多数组中的中转站效果。
详细内容，请看源代码解说。
(1)硬件渠道：
依据朱兆祺51单片机学习板。
(2)完结功用：
在第57节的串口收发程序基础上修正。在串口接纳函数中，以下代码有稍微修正：
while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4))//留意，这儿是4，不是上一节的5，由于只需eb 00 55 xx这4个数据
通过上位机来调用下位机对应的数组数据。
通过电脑串口调试帮手，往单片机发送EB 00 55 XX 指令，其间EB 00 55是数据头，XX的取值规模是0x01 至 0x05，每个不同的值代表调用下位机不同的数组数据。0x01调用第1组数据，0x02调用第2组数据，0x05调用第5组数据。
第1组：11 12 13 14 15
第2组：21 22 23 24 25
第3组：31 32 33 34 35
第4组：41 42 43 44 45
第5组：51 52 53 54 55
下位机回来21个数据，前面5个是第1种不带指针函数回来的数据。中心5个是第2种不带指针函数回来的数据。最终5个是第3种带指针函数回来的数据。期间2组EE EE EE是各函数回来的数据分割线，为了便利调查，没实践意义。
比方电脑发送：EB 0055 02
单片机就回来：21 2223 24 25 EE EE EE 21 22 23 24 25 EE EE EE 21 22 23 24 25
波特率是：9600 。
(3)源代码解说如下：
#include “REG52.H”
#define const_array_size 5 //参加排序的数组巨细
#define const_voice_short 40 //蜂鸣器短叫的持续时刻
#define const_rc_size 10 //接纳串口中止数据的缓冲区数组巨细
#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 send_array_1(unsigned char ucArraySec); //第1种函数，不带指针
void send_array_2(unsigned char ucArraySec); //第2种函数，不带指针
void send_array_3(unsigned char ucArraySec); //第3种函数，带指针
void eusart_send(unsigned char ucSendData);
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; //用来解析数据协议的中心变量
const unsigned char array_0x01[]={0x11,0x12,0x13,0x14,0x15}; //第1个常量数组
const unsigned char array_0x02[]={0x21,0x22,0x23,0x24,0x25}; //第2个常量数组
const unsigned char array_0x03[]={0x31,0x32,0x33,0x34,0x35}; //第3个常量数组
const unsigned char array_0x04[]={0x41,0x42,0x43,0x44,0x45}; //第4个常量数组
const unsigned char array_0x05[]={0x51,0x52,0x53,0x54,0x55}; //第5个常量数组
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
/* 注释一：
* 第1种函数，内部不带指针，依据上位机相关的指令，
* 直接回来对应的数组。由于不带指针，因而多用了5个for循环来搬运数组。
* 比较耗程序ROM容量，也不行简练明晰。
*/
void send_array_1(unsigned char ucArraySec)
{
unsigned int i;
switch(ucArraySec)
{
case 1: //直接回来第1个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x01[i]);
}
break;
case 2: //直接回来第2个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x02[i]);
}
break;
case 3: //直接回来第3个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x03[i]);
}
break;
case 4: //直接回来第4个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x04[i]);
}
break;
case 5: //直接回来第5个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x05[i]);
}
break;
}
}
/* 注释二：
* 第2种函数，内部不带指针，依据上位机相关的指令，
* 先搬运对应的数组放到一个中心变量数组，然后发送数组。
* 由于不带指针，因而多用了6个for循环来搬运数组。
* 跟第1种函数相同，比较耗程序ROM容量，也不行简练明晰。
*/
void send_array_2(unsigned char ucArraySec) //第2种函数，不带指针
{
unsigned int i;
unsigned char array_temp[5]; //暂时中心数组
switch(ucArraySec)
{
case 1: //直接回来第1个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x01[i]; //先挨个把对应的数组数据搬运到中心数组里
}
break;
case 2: //直接回来第2个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x02[i]; //先挨个把对应的数组数据搬运到中心数组里
}
break;
case 3: //直接回来第3个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x03[i]; //先挨个把对应的数组数据搬运到中心数组里
}
break;
case 4: //直接回来第4个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x04[i]; //先挨个把对应的数组数据搬运到中心数组里
}
break;
case 5: //直接回来第5个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x05[i]; //先挨个把对应的数组数据搬运到中心数组里
}
break;
}
for(i=0;i<5;i++)
{
eusart_send(array_temp[i]); //把暂时存放在中心数组的数据悉数发送出去
}
}
/* 注释三：
* 第3种函数，内部带指针，依据上位机相关的指令，
* 先把对应的数组首地址传递给一个中心指针，然后再通过
* 指针把整个数组的数据发送出去，由于带指针，切换搬运数组的数据十分快，
* 只需传递一下首地址给指针就能够，十分高效，整个函数只用了1个for循环。
* 跟前面第1,2种函数比较，愈加节约程序容量，处理速度愈加速，愈加简练。
*/
void send_array_3(unsigned char ucArraySec) //第3种函数，带指针
{
unsigned int i;
unsigned char *p_array; //暂时中心指针，作为数组的中转站，十分高效
switch(ucArraySec)
{
case 1: //直接回来第1个常量数组
p_array=array_0x01; //把数组的首地址传递给指针，一个指令就能够，不必for来挨个搬移数据，高效!
break;
case 2: //直接回来第2个常量数组
p_array=array_0x02; //把数组的首地址传递给指针，一个指令就能够，不必for来挨个搬移数据，高效!
break;
case 3: //直接回来第3个常量数组
p_array=array_0x03; //把数组的首地址传递给指针，一个指令就能够，不必for来挨个搬移数据，高效!
break;
case 4: //直接回来第4个常量数组
p_array=array_0x04; //把数组的首地址传递给指针，一个指令就能够，不必for来挨个搬移数据，高效!
break;
case 5: //直接回来第5个常量数组
p_array=array_0x05; //把数组的首地址传递给指针，一个指令就能够，不必for来挨个搬移数据，高效!
break;
}
for(i=0;i<5;i++)
{
eusart_send(p_array[i]); //通过指针把数组的数据悉数发送出去
}
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
unsigned char ucWhichArray;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //阐明超越了必定的时刻内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不必每次都进来,除非有新接纳的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判别数据头，所以下标移动变量从数组的0开端向最尾端移动
while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4)) //留意，这儿是4，不是上一节的5，由于只需eb 00 55 xx这4个数据
{
if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55) //数据头eb 00 55的判别
{
ucWhichArray=ucRcregBuf[uiRcMoveIndex+3]; //上位机需求回来的某个数组
send_array_1(ucWhichArray); //第1种函数回来数组的5个数据，不带指针
eusart_send(0xee); //为了便利上位机调查，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
send_array_2(ucWhichArray); //第2种函数回来数组的5个数据，不带指针
eusart_send(0xee); //为了便利上位机调查，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
send_array_3(ucWhichArray); //第3种函数回来数组的5个数据，带指针
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
{
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
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于履行一条空句子
}
}
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;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; //发动守时中止
}
总结陈词：
通过前面几节的学习，基本上讲完了我平常用指针的一切心得体会。
下一节开端讲新内容。在前面一些章节中，我说到为了避免中止函数把某些同享数据损坏，在主函数中更改某个数据变量时，应该先封闭中止，修正完后再翻开中止;我也说到了网友“红金龙吸味”关于原子锁的主张。通过这段时刻的考虑和总结，我发现不管是关中止开中止，仍是原子锁，其实本质上都是程序在多进程中临界点的数据处理，原子锁在程序员中有个专用名词叫互斥量，而我引认为豪的状态机程序结构，主函数的switch句子，外加一个守时中止，本质上便是2个独立进程在不断切换并行运转。我觉得这个临界点处理的常识很重要，也很简单疏忽，所以我决议专门用两节内容来讲讲这方面的常识使用。欲知概况，请听下回分解—–关中止和开中止在多进程临界点的使用。
