21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 从业将近十年！手把手教你单片机程序框架（连载） ...
1 ...171819202122232425... 45下一页
返回列表 发新帖我要提问

[51单片机] 从业将近十年！手把手教你单片机程序框架（连载）

[复制链接]
294020|913
高丽棒子 发表于 2014-7-2 09:19 | 显示全部楼层
楼主跟吴鉴鷹是啥关系。。
回复

收藏343 举报

riddickwoo 发表于 2014-7-2 10:46 | 显示全部楼层
为楼主赞一个。。持续关注！
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-7-2 15:59 | 显示全部楼层
高丽棒子 发表于 2014-7-2 09:19
楼主跟吴鉴鷹是啥关系。。

我跟吴鉴鹰没有啥关系，我只是看过他写的连载技术**，给我的感觉是，吴鉴鹰是一个幽默，帅气，非常热情，非常乐于分享技术的一个人。
回复

收藏343 举报

cx1234 发表于 2014-7-2 21:49 | 显示全部楼层
楼主 指针和结构体不用学么？
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-7-2 23:24 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-7-2 23:27 编辑
cx1234 发表于 2014-7-2 21:49
楼主 指针和结构体不用学么？

看个人情况吧。我觉得初学者可以不用急着学指针，等稍微有点编程感觉之后再学。结构体大概了解一下就可以了，我本人从来不用结构体。我指针也很少用，只有在涉及到数组，和函数返回值超过一个的情况下我才用指针。初学者如果不会指针，也不会影响编程，因为可以用其它方式替代指针。最近，我的连载技术贴恰好讲到指针这方面的知识。
回复

收藏343 举报

hww5408 发表于 2014-7-3 08:36 | 显示全部楼层
为楼主乐于分享个人技术的精神赞一个。。持续关注中！
回复

收藏343 举报

mangoshue 发表于 2014-7-3 09:01 | 显示全部楼层
够长的呀，内容很多。希望自己能看完。
回复

收藏343 举报

高丽棒子 发表于 2014-7-3 09:31 | 显示全部楼层
jianhong_wu 发表于 2014-7-2 15:59
我跟吴鉴鹰没有啥关系，我只是看过他写的连载技术**，给我的感觉是，吴鉴鹰是一个幽默，帅气，非常热情 ...

吴鉴鷹不等于吴鉴鸿么。。哈哈！
回复

收藏343 举报

Zhou_g 发表于 2014-7-3 17:19 | 显示全部楼层
谢谢楼主分享
回复

收藏343 举报

862722971 发表于 2014-7-3 17:29 | 显示全部楼层
楼主分享的东西确实好，不过一个优秀的工程师在编写程序前必然先画程序框图，程序框图的好坏决定着项目完成的质量，所以如果楼主能提供相应的程序框图，对初学者肯定大有帮助
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-7-3 18:35 | 显示全部楼层
862722971 发表于 2014-7-3 17:29
楼主分享的东西确实好，不过一个优秀的工程师在编写程序前必然先画程序框图，程序框图的好坏决定着项目完成 ...

我做项目从来不画程序框图，可能是因为我已经形成了固定的程序框架套路，所以再复杂的项目在我眼里都很清晰，不用画程序框图也能够游刃有余。
回复

收藏343 举报

hww5408 发表于 2014-7-4 11:30 | 显示全部楼层
同意楼主说法，因为用51单片机，程序量都是比较小的，写之前，程序框架已了然于胸，就像是1+1=2已经呈现于脑海，没必要再写出来。"不过一个优秀的工程师在编写程序前必然先画程序框图",这说法可以认同，但说得过于绝对。但是，如果是初学者，画一下是很有必要的。
哈哈，比如我们吴工，就不是一个优秀的工程师吗！？
回复

收藏343 举报

free_90 发表于 2014-7-5 21:23 | 显示全部楼层
顶
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-7-6 10:56 | 显示全部楼层
第五十四节：指针的第二大好处，指针作为数组在函数中的输入接口。

开场白：
如果不会指针，当我们想把一个数组的数据传递进某个函数内部的时候，只能通过全局变量的方式，这种方法的缺点是阅读不直观，封装性不强，没有面对用户的输入接口。
针对以上问题，这一节要教大家一个知识点：通过指针，为函数增加一个数组输入接口。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：
把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

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（3）源代码讲解如下：
复制
  1. #include "REG52.H"
    


  2. 


  3. 

  4. #define const_array_size  5  //参与排序的数组大小
    


  5. 

  6. #define const_voice_short  40   //蜂鸣器短叫的持续时间
    

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


  8. 

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


  10. 

  11. void initial_myself(void);    
    

  12. void initial_peripheral(void);
    

  13. void delay_long(unsigned int uiDelaylong);
    

  14. void delay_short(unsigned int uiDelayShort); 
    


  15. 


  16. 

  17. void T0_time(void);  //定时中断函数
    

  18. void usart_receive(void); //串口接收中断函数
    

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


  20. 


  21. 

  22. void eusart_send(unsigned char ucSendData);
    


  23. 

  24. void big_to_small_sort_1(void);//第1种方法 把一个数组从大小小排序
    

  25. void big_to_small_sort_2(unsigned char *p_ucInputBuffer);//第2种方法 把一个数组从大小小排序
    


  26. 

  27. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
    


  28. 

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

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

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

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

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


  34. 

  35. unsigned char ucUsartBuffer[const_array_size];  //从串口接收到的需要排序的原始数据
    

  36. unsigned char ucGlobalBuffer_1[const_array_size]; //第1种方法，参与具体排序算法的全局变量数组
    

  37. unsigned char ucGlobalBuffer_2[const_array_size]; //第2种方法，参与具体排序算法的全局变量数组
    

  38. void main() 
    

  39.   {
    

  40.    initial_myself();  
    

  41.    delay_long(100);   
    

  42.    initial_peripheral(); 
    

  43.    while(1)  
    

  44.    { 
    

  45.        usart_service();  //串口服务程序
    

  46.    }
    


  47. 

  48. }
    


  49. 


  50. 

  51. /* 注释一：
    

  52.  * 第1种方法，用不带输入输出接口的空函数，这是最原始的做法，它完全依靠
    

  53.  * 全局变量作为函数的输入和输出口。我们要用到这个函数，就要把参与运算
    

  54.  * 的变量直接赋给对应的输入全局变量，调用一次函数之后，再找到对应的
    

  55.  * 输出全局变量，这些输出全局变量就是我们要的结果。
    

  56.  * 在本函数中，ucGlobalBuffer_1[const_array_size]既是输入全局变量，也是输出全局变量，
    

  57.  * 这种方法的缺点是阅读不直观，封装性不强，没有面对用户的输入输出接口，
    

  58.  */
    

  59. void big_to_small_sort_1(void)//第1种方法 把一个数组从大小小排序
    

  60. {
    

  61.    unsigned char i;
    

  62.    unsigned char k;
    

  63.    unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
    


  64. 

  65. /* 注释二：
    

  66.  * 以下就是著名的 冒泡法排序。这个方法几乎所有的C语言大学教材都讲过了。大家在百度上可以直接
    

  67.  * 搜索到它的工作原理和详细的讲解步骤，我就不再详细讲解了。
    

  68.  */
    

  69.    for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
    

  70.    {
    

  71.       for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
    

  72.           {
    

  73.              if(ucGlobalBuffer_1[const_array_size-1-k]>ucGlobalBuffer_1[const_array_size-1-1-k])  //后一个与前一个数据两两比较
    

  74.                  {
    

  75.                      ucTemp=ucGlobalBuffer_1[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
    

  76.              ucGlobalBuffer_1[const_array_size-1-1-k]=ucGlobalBuffer_1[const_array_size-1-k];
    

  77.              ucGlobalBuffer_1[const_array_size-1-k]=ucTemp;
    

  78.                  }
    

  79.           
    

  80.           }
    

  81.    }
    


  82. 

  83. }
    


  84. 

  85. /* 注释三：
    

  86.  * 第2种方法，为了改进第1种方法的用户体验，用指针为函数增加一个输入接口。
    

  87.  * 为什么要用指针？因为C语言的函数中，数组不能直接用来做函数的形参，只能用指针作为数组的形参。
    

  88.  * 比如，你不能这样写一个函数void big_to_small_sort_2(unsigned char a[5])，否则编译就会出错不通过。
    

  89.  * 在本函数中，*p_ucInputBuffer指针就是输入接口，而输出接口仍然是全局变量数组ucGlobalBuffer_2。
    

  90.  * 这种方法由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了。
    

  91.  */
    

  92. void big_to_small_sort_2(unsigned char *p_ucInputBuffer)//第2种方法 把一个数组从大小小排序
    

  93. {
    

  94.    unsigned char i;
    

  95.    unsigned char k;
    

  96.    unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
    


  97. 


  98. 

  99.    for(i=0;i<const_array_size;i++)  
    

  100.    {
    

  101.       ucGlobalBuffer_2[i]=p_ucInputBuffer[i];  //参与排序算法之前，先把输入接口的数据全部搬移到全局变量数组中。
    

  102.    }
    


  103. 


  104. 

  105.    //以下就是著名的 冒泡法排序。详细讲解请找百度。
    

  106.    for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
    

  107.    {
    

  108.       for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
    

  109.           {
    

  110.              if(ucGlobalBuffer_2[const_array_size-1-k]>ucGlobalBuffer_2[const_array_size-1-1-k])  //后一个与前一个数据两两比较
    

  111.                  {
    

  112.                      ucTemp=ucGlobalBuffer_2[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
    

  113.              ucGlobalBuffer_2[const_array_size-1-1-k]=ucGlobalBuffer_2[const_array_size-1-k];
    

  114.              ucGlobalBuffer_2[const_array_size-1-k]=ucTemp;
    

  115.                  }
    

  116.           
    

  117.           }
    

  118.    }
    


  119. 

  120. }
    


  121. 


  122. 


  123. 

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

  125. {
    


  126. 

  127.      unsigned char i=0;   
    


  128. 

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

  130.      {
    


  131. 

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


  133. 

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


  135. 

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


  137. 

  138.             while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) 
    

  139.             {
    

  140.                if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
    

  141.                {
    


  142. 


  143. 

  144.                                   for(i=0;i<const_array_size;i++)
    

  145.                                   {
    

  146.                      ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
    

  147.                                   }
    


  148. 


  149. 

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

  151.                                   for(i=0;i<const_array_size;i++)
    

  152.                                   {
    

  153.                                      ucGlobalBuffer_1[i]=ucUsartBuffer[i];  //把需要被排列的数据放进输入全局变量数组
    

  154.                                   }
    

  155.                   big_to_small_sort_1(); //调用一次空函数就出结果了，结果还是保存在ucGlobalBuffer_1全局变量数组中
    

  156.                   for(i=0;i<const_array_size;i++)
    

  157.                                   {
    

  158.                                     eusart_send(ucGlobalBuffer_1[i]);  ////把用第1种方法排序后的结果返回给上位机观察
    

  159.                                   }
    


  160. 


  161. 

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

  163.                                   eusart_send(0xee); 
    

  164.                                   eusart_send(0xee); 
    


  165. 

  166.                   //第2种运算方法，依靠指针为函数增加一个数组的输入接口
    

  167.                                   //通过指针输入接口，直接把ucUsartBuffer数组的首地址传址进去，排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中
    

  168.                   big_to_small_sort_2(ucUsartBuffer); 
    

  169.                   for(i=0;i<const_array_size;i++)
    

  170.                                   {
    

  171.                                     eusart_send(ucGlobalBuffer_2[i]);  //把用第2种方法排序后的结果返回给上位机观察
    

  172.                                   }
    


  173. 


  174. 


  175. 


  176. 


  177. 

  178.                   break;   //退出循环
    

  179.                }
    

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

  181.            }
    

  182.                                          
    

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

  184.   
    

  185.      }
    

  186.                          
    

  187. }
    


  188. 

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

  190. {
    


  191. 

  192.   ES = 0; //关串口中断
    

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

  194.   SBUF =ucSendData; //发送一个字节
    


  195. 

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


  197. 

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

  199.   ES = 1; //允许串口中断
    


  200. 

  201. }
    


  202. 


  203. 


  204. 

  205. void T0_time(void) interrupt 1    //定时中断
    

  206. {
    

  207.   TF0=0;  //清除中断标志
    

  208.   TR0=0; //关中断
    


  209. 


  210. 

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

  212.   {
    

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

  214.       ucSendLock=1;     //开自锁标志
    

  215.   }
    


  216. 


  217. 


  218. 

  219.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
    

  220.   TL0=0x0b;
    

  221.   TR0=1;  //开中断
    

  222. }
    


  223. 


  224. 

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

  226. {        
    


  227. 

  228.    if(RI==1)  
    

  229.    {
    

  230.         RI = 0;
    


  231. 

  232.             ++uiRcregTotal;
    

  233.         if(uiRcregTotal>const_rc_size)  //超过缓冲区
    

  234.         {
    

  235.            uiRcregTotal=const_rc_size;
    

  236.         }
    

  237.         ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
    

  238.         uiSendCnt=0;  //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
    

  239.     
    

  240.    }
    

  241.    else  //发送中断，及时把发送中断标志位清零
    

  242.    {
    

  243.         TI = 0;
    

  244.    }
    

  245.                                                          
    

  246. }                                
    


  247. 


  248. 

  249. void delay_long(unsigned int uiDelayLong)
    

  250. {
    

  251.    unsigned int i;
    

  252.    unsigned int j;
    

  253.    for(i=0;i<uiDelayLong;i++)
    

  254.    {
    

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

  256.           {
    

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

  258.           }
    

  259.    }
    

  260. }
    


  261. 

  262. void delay_short(unsigned int uiDelayShort) 
    

  263. {
    

  264.    unsigned int i;  
    

  265.    for(i=0;i<uiDelayShort;i++)
    

  266.    {
    

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

  268.    }
    

  269. }
    


  270. 


  271. 

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

  273. {
    


  274. 

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


  276. 

  277.   //配置定时器
    

  278.   TMOD=0x01;  //设置定时器0为工作方式1
    

  279.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
    

  280.   TL0=0x0b;
    


  281. 


  282. 

  283.   //配置串口
    

  284.   SCON=0x50;
    

  285.   TMOD=0X21;
    

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

  287.   TR1=1;
    


  288. 

  289. }
    


  290. 

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

  292. {
    


  293. 

  294.    EA=1;     //开总中断
    

  295.    ES=1;     //允许串口中断
    

  296.    ET0=1;    //允许定时中断
    

  297.    TR0=1;    //启动定时中断
    


  298. 

  299. }
总结陈词：
第2种方法通过指针，为函数增加了一个数组输入接口，已经比第1种纯粹用全局变量的方法直观多了，但是还有一个小小的遗憾，因为它的输出排序结果仍然要靠全局变量。为了让函数更加完美，我们能不能为函数再增加一个输出接口？当然可以。欲知详情，请听下回分解-----指针的第三大好处，指针作为数组在函数中的输出接口。

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

收藏343 举报

chen125318 发表于 2014-7-9 11:29 | 显示全部楼层
时不时的上来看看 很有收获
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-7-10 15:07 | 显示全部楼层
第五十五节：指针的第三大好处，指针作为数组在函数中的输出接口。

开场白：
上一节介绍的第2种方法，由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了，但是由于只有输入接口，没有输出接口，输出接口仍然要靠全局变量数组，所以还是有一个小小的遗憾，这节介绍的第3种方法就是为了改变这个遗憾，为数组在函数中多增加一个输出接口，这样，函数既有输入接口，又有输出接口，这样的函数才算完美直观。这一节要教大家一个知识点：通过指针，为函数增加一个数组输出接口。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：
把5个随机数据按从大到小排序，用冒泡法来排序。
通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07  指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第2种方法的排序结果，中间3个数据EE EE EE是第2种和第3种的分割线，为了方便观察，没实际意义。最后5个数据是第3种方法的排序结果.

比如电脑发送：EB 00 55 08 06 09 05 07
单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（3）源代码讲解如下：
复制
  1. #include "REG52.H"
    


  2. 


  3. 

  4. #define const_array_size  5  //参与排序的数组大小
    


  5. 

  6. #define const_voice_short  40   //蜂鸣器短叫的持续时间
    

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


  8. 

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


  10. 

  11. void initial_myself(void);    
    

  12. void initial_peripheral(void);
    

  13. void delay_long(unsigned int uiDelaylong);
    

  14. void delay_short(unsigned int uiDelayShort); 
    


  15. 


  16. 

  17. void T0_time(void);  //定时中断函数
    

  18. void usart_receive(void); //串口接收中断函数
    

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


  20. 


  21. 

  22. void eusart_send(unsigned char ucSendData);
    


  23. 


  24. 

  25. void big_to_small_sort_2(unsigned char *p_ucInputBuffer);//第2种方法 把一个数组从大到小排序
    

  26. void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer);//第3种方法 把一个数组从大到小排序
    

  27. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
    


  28. 

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

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

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

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

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


  34. 

  35. unsigned char ucUsartBuffer[const_array_size];  //从串口接收到的需要排序的原始数据
    


  36. 

  37. unsigned char ucGlobalBuffer_2[const_array_size]; //第2种方法，参与具体排序算法的全局变量数组
    

  38. unsigned char ucGlobalBuffer_3[const_array_size]; //第3种方法，用来接收输出接口数据的全局变量数组
    


  39. 

  40. void main() 
    

  41.   {
    

  42.    initial_myself();  
    

  43.    delay_long(100);   
    

  44.    initial_peripheral(); 
    

  45.    while(1)  
    

  46.    { 
    

  47.        usart_service();  //串口服务程序
    

  48.    }
    


  49. 

  50. }
    


  51. 


  52. 


  53. 

  54. /* 注释一：
    

  55.  * 第2种方法，为了改进第1种方法的用户体验，用指针为函数增加一个输入接口。
    

  56.  * 为什么要用指针？因为C语言的函数中，数组不能直接用来做函数的形参，只能用指针作为数组的形参。
    

  57.  * 比如，你不能这样写一个函数void big_to_small_sort_2(unsigned char a[5])，否则编译就会出错不通过。
    

  58.  * 在本函数中，*p_ucInputBuffer指针就是输入接口，而输出接口仍然是全局变量数组ucGlobalBuffer_2。
    

  59.  * 这种方法由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了，但是由于只有输入接口，
    

  60.  * 没有输出接口，输出接口仍然要靠全局变量，所以还是有点小遗憾，以下第3种方法就是为了改变这个遗憾。
    

  61.  */
    

  62. void big_to_small_sort_2(unsigned char *p_ucInputBuffer)//第2种方法 把一个数组从大到小排序
    

  63. {
    

  64.    unsigned char i;
    

  65.    unsigned char k;
    

  66.    unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
    


  67. 


  68. 

  69.    for(i=0;i<const_array_size;i++)  
    

  70.    {
    

  71.       ucGlobalBuffer_2[i]=p_ucInputBuffer[i];  //参与排序算法之前，先把输入接口的数据全部搬移到全局变量数组中。
    

  72.    }
    


  73. 


  74. 

  75.    //以下就是著名的 冒泡法排序。详细讲解请找百度。
    

  76.    for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
    

  77.    {
    

  78.       for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
    

  79.           {
    

  80.              if(ucGlobalBuffer_2[const_array_size-1-k]>ucGlobalBuffer_2[const_array_size-1-1-k])  //后一个与前一个数据两两比较
    

  81.                  {
    

  82.                      ucTemp=ucGlobalBuffer_2[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
    

  83.              ucGlobalBuffer_2[const_array_size-1-1-k]=ucGlobalBuffer_2[const_array_size-1-k];
    

  84.              ucGlobalBuffer_2[const_array_size-1-k]=ucTemp;
    

  85.                  }
    

  86.           
    

  87.           }
    

  88.    }
    


  89. 

  90. }
    


  91. 


  92. 


  93. 

  94. /* 注释二：
    

  95.  * 第3种方法，为了改进第2种方法的用户体验，用指针为函数多增加一个数组输出接口。
    

  96.  * 这样，函数的数组既有输入接口，又有输出接口，已经堪称完美了。
    

  97.  * 本程序中*p_ucInputBuffer输入接口，*p_ucOutputBuffer是输出接口。
    

  98.  */
    

  99. void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer)//第3种方法 把一个数组从大到小排序
    

  100. {
    

  101.    unsigned char i;
    

  102.    unsigned char k;
    

  103.    unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
    

  104.    unsigned char ucBuffer_3[const_array_size]; //第3种方法，参与具体排序算法的局部变量数组
    


  105. 

  106.    for(i=0;i<const_array_size;i++)  
    

  107.    {
    

  108.       ucBuffer_3[i]=p_ucInputBuffer[i];  //参与排序算法之前，先把输入接口的数据全部搬移到局部变量数组中。
    

  109.    }
    


  110. 


  111. 

  112.    //以下就是著名的 冒泡法排序。详细讲解请找百度。
    

  113.    for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
    

  114.    {
    

  115.       for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
    

  116.           {
    

  117.              if(ucBuffer_3[const_array_size-1-k]>ucBuffer_3[const_array_size-1-1-k])  //后一个与前一个数据两两比较
    

  118.                  {
    

  119.                      ucTemp=ucBuffer_3[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
    

  120.              ucBuffer_3[const_array_size-1-1-k]=ucBuffer_3[const_array_size-1-k];
    

  121.              ucBuffer_3[const_array_size-1-k]=ucTemp;
    

  122.                  }
    

  123.           
    

  124.           }
    

  125.    }
    


  126. 


  127. 

  128.    for(i=0;i<const_array_size;i++)  
    

  129.    {
    

  130.       p_ucOutputBuffer[i]=ucBuffer_3[i];  //参与排序算法之后，把运算结果的数据全部搬移到输出接口中，方便外面程序调用
    

  131.    }
    

  132. }
    


  133. 


  134. 


  135. 


  136. 

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

  138. {
    


  139. 

  140.      unsigned char i=0;   
    


  141. 

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

  143.      {
    


  144. 

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


  146. 

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


  148. 

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


  150. 

  151.             while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) 
    

  152.             {
    

  153.                if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
    

  154.                {
    


  155. 


  156. 

  157.                                   for(i=0;i<const_array_size;i++)
    

  158.                                   {
    

  159.                      ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
    

  160.                                   }
    


  161. 


  162. 

  163.                   //第2种运算方法，依靠指针为函数增加一个数组的输入接口
    

  164.                                   //通过指针输入接口，直接把ucUsartBuffer数组的首地址传址进去，排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中
    

  165.                   big_to_small_sort_2(ucUsartBuffer); 
    

  166.                   for(i=0;i<const_array_size;i++)
    

  167.                                   {
    

  168.                                     eusart_send(ucGlobalBuffer_2[i]);  //把用第2种方法排序后的结果返回给上位机观察
    

  169.                                   }
    


  170. 


  171. 

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

  173.                                   eusart_send(0xee); 
    

  174.                                   eusart_send(0xee); 
    


  175. 

  176.                   //第3种运算方法，依靠指针为函数增加一个数组的输出接口
    

  177.                                   //通过指针输出接口，排序运算后的结果直接从这个输出口中导出到ucGlobalBuffer_3数组中
    

  178.                   big_to_small_sort_3(ucUsartBuffer,ucGlobalBuffer_3);   //ucUsartBuffer是输入的数组，ucGlobalBuffer_3是接收排序结果的数组
    

  179.                   for(i=0;i<const_array_size;i++)
    

  180.                                   {
    

  181.                                     eusart_send(ucGlobalBuffer_3[i]);  //把用第3种方法排序后的结果返回给上位机观察
    

  182.                                   }
    


  183. 


  184. 


  185. 

  186.                   break;   //退出循环
    

  187.                }
    

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

  189.            }
    

  190.                                          
    

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

  192.   
    

  193.      }
    

  194.                          
    

  195. }
    


  196. 

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

  198. {
    


  199. 

  200.   ES = 0; //关串口中断
    

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

  202.   SBUF =ucSendData; //发送一个字节
    


  203. 

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


  205. 

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

  207.   ES = 1; //允许串口中断
    


  208. 

  209. }
    


  210. 


  211. 


  212. 

  213. void T0_time(void) interrupt 1    //定时中断
    

  214. {
    

  215.   TF0=0;  //清除中断标志
    

  216.   TR0=0; //关中断
    


  217. 


  218. 

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

  220.   {
    

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

  222.       ucSendLock=1;     //开自锁标志
    

  223.   }
    


  224. 


  225. 


  226. 

  227.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
    

  228.   TL0=0x0b;
    

  229.   TR0=1;  //开中断
    

  230. }
    


  231. 


  232. 

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

  234. {        
    


  235. 

  236.    if(RI==1)  
    

  237.    {
    

  238.         RI = 0;
    


  239. 

  240.             ++uiRcregTotal;
    

  241.         if(uiRcregTotal>const_rc_size)  //超过缓冲区
    

  242.         {
    

  243.            uiRcregTotal=const_rc_size;
    

  244.         }
    

  245.         ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
    

  246.         uiSendCnt=0;  //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
    

  247.     
    

  248.    }
    

  249.    else  //发送中断，及时把发送中断标志位清零
    

  250.    {
    

  251.         TI = 0;
    

  252.    }
    

  253.                                                          
    

  254. }                                
    


  255. 


  256. 

  257. void delay_long(unsigned int uiDelayLong)
    

  258. {
    

  259.    unsigned int i;
    

  260.    unsigned int j;
    

  261.    for(i=0;i<uiDelayLong;i++)
    

  262.    {
    

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

  264.           {
    

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

  266.           }
    

  267.    }
    

  268. }
    


  269. 

  270. void delay_short(unsigned int uiDelayShort) 
    

  271. {
    

  272.    unsigned int i;  
    

  273.    for(i=0;i<uiDelayShort;i++)
    

  274.    {
    

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

  276.    }
    

  277. }
    


  278. 


  279. 

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

  281. {
    


  282. 

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


  284. 

  285.   //配置定时器
    

  286.   TMOD=0x01;  //设置定时器0为工作方式1
    

  287.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
    

  288.   TL0=0x0b;
    


  289. 


  290. 

  291.   //配置串口
    

  292.   SCON=0x50;
    

  293.   TMOD=0X21;
    

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

  295.   TR1=1;
    


  296. 

  297. }
    


  298. 

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

  300. {
    


  301. 

  302.    EA=1;     //开总中断
    

  303.    ES=1;     //允许串口中断
    

  304.    ET0=1;    //允许定时中断
    

  305.    TR0=1;    //启动定时中断
    


  306. 

  307. }
总结陈词：
通过本节程序的讲解，一部分细心的读者可能会发现一个规律，其实所谓指针作为数组在函数中的输入接口和输出接口，输入接口的指针跟输出接口的指针在语法上没有任何区别，我没有用到C语言中专门的关键词去限定某个指针是输入，某个指针是输出，因此，这个告诉我们什么道理？指针在函数的接口中，天生就是既可以做输入，也可以是做输出，它是双向性的，不像普通的函数变量形参只能做输入。发现了这个秘密，我们可不可以把本节程序中的输入接口和输出接口合并成一个输入输出接口？当然可以。欲知详情，请听下回分解-----指针的第四大好处，指针作为数组在函数中的输入输出接口。

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

收藏343 举报

 楼主| jianhong_wu 发表于 2014-7-10 17:29 | 显示全部楼层
第五十六节：指针的第四大好处，指针作为数组在函数中的输入输出接口。

开场白：
通过前面几个章节的学习，我们知道指针在函数的接口中，天生就是既可以做输入，也可以是做输出，它是双向性的，类似全局变量的特点。我们根据实际项目的情况，在必要的时候可以直接把输入接口和输出接口合并在一起，这种方法的缺点是没有把输入和输出分开，没有那么直观。但是优点也是很明显的，就是比较省程序ROM容量和数据RAM容量，而且运行效率也比较快。这一节要教大家一个知识点：指针作为数组在函数中输入输出接口的特点。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：
把5个随机数据按从大到小排序，用冒泡法来排序。
通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07  指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第3种方法的排序结果，中间3个数据EE EE EE是第3种和第4种的分割线，为了方便观察，没实际意义。最后5个数据是第4种方法的排序结果.

比如电脑发送：EB 00 55 08 06 09 05 07
单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（3）源代码讲解如下：
复制
  1. #include "REG52.H"
    


  2. 


  3. 

  4. #define const_array_size  5  //参与排序的数组大小
    


  5. 

  6. #define const_voice_short  40   //蜂鸣器短叫的持续时间
    

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


  8. 

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


  10. 

  11. void initial_myself(void);    
    

  12. void initial_peripheral(void);
    

  13. void delay_long(unsigned int uiDelaylong);
    

  14. void delay_short(unsigned int uiDelayShort); 
    


  15. 


  16. 

  17. void T0_time(void);  //定时中断函数
    

  18. void usart_receive(void); //串口接收中断函数
    

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


  20. 


  21. 

  22. void eusart_send(unsigned char ucSendData);
    


  23. 

  24. void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer);//第3种方法 把一个数组从大到小排序
    

  25. void big_to_small_sort_4(unsigned char *p_ucInputAndOutputBuffer);//第4种方法 把一个数组从大到小排序
    

  26. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
    


  27. 

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

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

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

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

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


  33. 

  34. unsigned char ucUsartBuffer[const_array_size];  //从串口接收到的需要排序的原始数据
    


  35. 

  36. unsigned char ucGlobalBuffer_3[const_array_size]; //第3种方法，用来接收输出接口数据的全局变量数组
    

  37. unsigned char ucGlobalBuffer_4[const_array_size]; //第4种方法，用来输入和输出接口数据的全局变量数组
    

  38. void main() 
    

  39.   {
    

  40.    initial_myself();  
    

  41.    delay_long(100);   
    

  42.    initial_peripheral(); 
    

  43.    while(1)  
    

  44.    { 
    

  45.        usart_service();  //串口服务程序
    

  46.    }
    


  47. 

  48. }
    


  49. 


  50. 


  51. 


  52. 

  53. /* 注释一：
    

  54.  * 第3种方法，为了改进第2种方法的用户体验，用指针为函数多增加一个数组输出接口。
    

  55.  * 这样，函数的数组既有输入接口，又有输出接口，已经堪称完美了。
    

  56.  * 本程序中*p_ucInputBuffer输入接口，*p_ucOutputBuffer是输出接口。
    

  57.  */
    

  58. void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer)//第3种方法 把一个数组从大到小排序
    

  59. {
    

  60.    unsigned char i;
    

  61.    unsigned char k;
    

  62.    unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
    

  63.    unsigned char ucBuffer_3[const_array_size]; //第3种方法，参与具体排序算法的局部变量数组
    


  64. 

  65.    for(i=0;i<const_array_size;i++)  
    

  66.    {
    

  67.       ucBuffer_3[i]=p_ucInputBuffer[i];  //参与排序算法之前，先把输入接口的数据全部搬移到局部变量数组中。
    

  68.    }
    


  69. 


  70. 

  71.    //以下就是著名的 冒泡法排序。详细讲解请找百度。
    

  72.    for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
    

  73.    {
    

  74.       for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
    

  75.           {
    

  76.              if(ucBuffer_3[const_array_size-1-k]>ucBuffer_3[const_array_size-1-1-k])  //后一个与前一个数据两两比较
    

  77.                  {
    

  78.                      ucTemp=ucBuffer_3[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
    

  79.              ucBuffer_3[const_array_size-1-1-k]=ucBuffer_3[const_array_size-1-k];
    

  80.              ucBuffer_3[const_array_size-1-k]=ucTemp;
    

  81.                  }
    

  82.           
    

  83.           }
    

  84.    }
    


  85. 


  86. 

  87.    for(i=0;i<const_array_size;i++)  
    

  88.    {
    

  89.       p_ucOutputBuffer[i]=ucBuffer_3[i];  //参与排序算法之后，把运算结果的数据全部搬移到输出接口中，方便外面程序调用
    

  90.    }
    

  91. }
    


  92. 


  93. 

  94. /* 注释二：
    

  95.  * 第4种方法.指针在函数的接口中，天生就是既可以做输入，也可以是做输出，它是双向性的，类似全局变量的特点。
    

  96.  * 我们可以根据实际项目的情况，在必要的时候可以直接把输入接口和输出接口合并在一起，
    

  97.  * 这种方法的缺点是没有把输入和输出分开，没有那么直观。但是优点也是很明显的，就是比较
    

  98.  * 省程序ROM容量和数据RAM容量，而且运行效率也比较快。现在介绍给大家。
    

  99.  * 本程序的*p_ucInputAndOutputBuffer是输入输出接口。
    

  100.  */
    

  101. void big_to_small_sort_4(unsigned char *p_ucInputAndOutputBuffer)//第4种方法 把一个数组从大到小排序
    

  102. {
    

  103.    unsigned char i;
    

  104.    unsigned char k;
    

  105.    unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
    


  106. 

  107.    //以下就是著名的 冒泡法排序。详细讲解请找百度。
    

  108.    for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
    

  109.    {
    

  110.       for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
    

  111.           {
    

  112.              if(p_ucInputAndOutputBuffer[const_array_size-1-k]>p_ucInputAndOutputBuffer[const_array_size-1-1-k])  //后一个与前一个数据两两比较
    

  113.                  {
    

  114.                      ucTemp=p_ucInputAndOutputBuffer[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
    

  115.              p_ucInputAndOutputBuffer[const_array_size-1-1-k]=p_ucInputAndOutputBuffer[const_array_size-1-k];
    

  116.              p_ucInputAndOutputBuffer[const_array_size-1-k]=ucTemp;
    

  117.                  }
    

  118.           
    

  119.           }
    

  120.    }
    


  121. 


  122. 

  123. }
    


  124. 


  125. 

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

  127. {
    


  128. 

  129.      unsigned char i=0;   
    


  130. 

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

  132.      {
    


  133. 

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


  135. 

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


  137. 

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


  139. 

  140.             while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) 
    

  141.             {
    

  142.                if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
    

  143.                {
    


  144. 


  145. 

  146.                                   for(i=0;i<const_array_size;i++)
    

  147.                                   {
    

  148.                      ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
    

  149.                                   }
    


  150. 


  151. 

  152.                   //第3种运算方法，依靠指针为函数增加一个数组的输出接口
    

  153.                                   //通过指针输出接口，排序运算后的结果直接从这个输出口中导出到ucGlobalBuffer_3数组中
    

  154.                   big_to_small_sort_3(ucUsartBuffer,ucGlobalBuffer_3);   //ucUsartBuffer是输入的数组，ucGlobalBuffer_3是接收排序结果的数组
    

  155.                   for(i=0;i<const_array_size;i++)
    

  156.                                   {
    

  157.                                     eusart_send(ucGlobalBuffer_3[i]);  //把用第3种方法排序后的结果返回给上位机观察
    

  158.                                   }
    


  159. 

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

  161.                                   eusart_send(0xee); 
    

  162.                                   eusart_send(0xee); 
    


  163. 

  164.                   //第4种运算方法，依靠一个指针作为函数的输入输出接口。
    

  165.                                   //通过这个指针输入输出接口，ucGlobalBuffer_4数组既是输入数组，也是输出数组，排序运算后的结果直接存放在它本身，类似于全局变量的特点。
    

  166.                                   for(i=0;i<const_array_size;i++)
    

  167.                                   {
    

  168.                      ucGlobalBuffer_4[i]=ucUsartBuffer[i]; //把需要被排序的原始数据传递给接收输入输出数组ucGlobalBuffer_4，
    

  169.                                   }
    

  170.                   big_to_small_sort_4(ucGlobalBuffer_4);  
    

  171.                   for(i=0;i<const_array_size;i++)
    

  172.                                   {
    

  173.                                     eusart_send(ucGlobalBuffer_4[i]);  //把用第4种方法排序后的结果返回给上位机观察
    

  174.                                   }
    


  175. 


  176. 

  177.                   break;   //退出循环
    

  178.                }
    

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

  180.            }
    

  181.                                          
    

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

  183.   
    

  184.      }
    

  185.                          
    

  186. }
    


  187. 

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

  189. {
    


  190. 

  191.   ES = 0; //关串口中断
    

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

  193.   SBUF =ucSendData; //发送一个字节
    


  194. 

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


  196. 

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

  198.   ES = 1; //允许串口中断
    


  199. 

  200. }
    


  201. 


  202. 


  203. 

  204. void T0_time(void) interrupt 1    //定时中断
    

  205. {
    

  206.   TF0=0;  //清除中断标志
    

  207.   TR0=0; //关中断
    


  208. 


  209. 

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

  211.   {
    

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

  213.       ucSendLock=1;     //开自锁标志
    

  214.   }
    


  215. 


  216. 


  217. 

  218.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
    

  219.   TL0=0x0b;
    

  220.   TR0=1;  //开中断
    

  221. }
    


  222. 


  223. 

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

  225. {        
    


  226. 

  227.    if(RI==1)  
    

  228.    {
    

  229.         RI = 0;
    


  230. 

  231.             ++uiRcregTotal;
    

  232.         if(uiRcregTotal>const_rc_size)  //超过缓冲区
    

  233.         {
    

  234.            uiRcregTotal=const_rc_size;
    

  235.         }
    

  236.         ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
    

  237.         uiSendCnt=0;  //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
    

  238.     
    

  239.    }
    

  240.    else  //发送中断，及时把发送中断标志位清零
    

  241.    {
    

  242.         TI = 0;
    

  243.    }
    

  244.                                                          
    

  245. }                                
    


  246. 


  247. 

  248. void delay_long(unsigned int uiDelayLong)
    

  249. {
    

  250.    unsigned int i;
    

  251.    unsigned int j;
    

  252.    for(i=0;i<uiDelayLong;i++)
    

  253.    {
    

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

  255.           {
    

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

  257.           }
    

  258.    }
    

  259. }
    


  260. 

  261. void delay_short(unsigned int uiDelayShort) 
    

  262. {
    

  263.    unsigned int i;  
    

  264.    for(i=0;i<uiDelayShort;i++)
    

  265.    {
    

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

  267.    }
    

  268. }
    


  269. 


  270. 

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

  272. {
    


  273. 

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


  275. 

  276.   //配置定时器
    

  277.   TMOD=0x01;  //设置定时器0为工作方式1
    

  278.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
    

  279.   TL0=0x0b;
    


  280. 


  281. 

  282.   //配置串口
    

  283.   SCON=0x50;
    

  284.   TMOD=0X21;
    

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

  286.   TR1=1;
    


  287. 

  288. }
    


  289. 

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

  291. {
    


  292. 

  293.    EA=1;     //开总中断
    

  294.    ES=1;     //允许串口中断
    

  295.    ET0=1;    //允许定时中断
    

  296.    TR0=1;    //启动定时中断
    


  297. 

  298. }
总结陈词：
通过本章的学习，我们知道指针在函数接口中的双向性，这个双向性是一把双刃剑，既给我们带来便捷，也给我们在以下两个场合中带来隐患。
第一个场合：当需要把输入接口和输出接口分开时，我们希望输入接口的参数不要被意外改变，改变的仅仅只能是输出接口的数据。但是指针的双向性，就有可能导致我们在写函数内部代码的时候一不小心改变而没有发觉。
第二个场合：如果是一个现成封装好的函数直接给我们调用，当我们发现是指针作为接口的时候，我们就不敢确定这个接口是输入接口，还是输出接口，或者是输入输出接口，我们传递进去的参数可能会更改，除非用之前进行数据备份，否则是没有安全感可言的。
有没有办法巧妙的解决以上两个问题？当然有。欲知详情，请听下回分解-----为指针加上紧箍咒const，避免意外修改了只做输入接口的数据。

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

收藏343 举报

zxb忘记 发表于 2014-7-10 19:31 | 显示全部楼层
讲解的真是详细啊，多谢楼主
回复

收藏343 举报

zxb忘记 发表于 2014-7-10 22:17 | 显示全部楼层
jianhong_wu 发表于 2014-3-5 21:53
第一节：吴坚鸿谈初学单片机的误区。

（1）很难记住繁杂的寄存器？寄存器不用死记硬背，鸿哥我行走江湖多 ...

大力支持！！！
回复

收藏343 举报

睡神耗子 发表于 2014-7-11 14:02 | 显示全部楼层
Mark一下。用来参考借鉴
回复

收藏343 举报

下一页 »
1 ...171819202122232425... 45下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部