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

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

[复制链接]
293907|913
 楼主| jianhong_wu 发表于 2014-4-5 23:06 | 显示全部楼层
cjseng 发表于 2014-4-5 21:53
鸿哥，你知道你单片机不能做精确定时的原因了吗？
你每次用到定时中断，都是先把定时器停掉，然后执行一端 ...

其实你说的这些问题之前也有很多人跟我质疑过。
（1）如果不是做实时时钟，我这样的时间精度可以满足绝大多数的项目要求的。如果要求再高一点的，就不要把按键扫描放在定时中断里，也不要选用动态数码管扫描的方案。
（2）如果是做实时时钟等精度非常高的，我还是觉得不适合用单片机来做。应该直接用时钟芯片或者cpld/FPGA来做。
（3）至于我每次进入定时中断之后都关闭中断，退出的时候才打开中断，这个是我多年的使用习惯，我觉得不会影响我对时间的要求。当然，在这一点上也许不关闭定时中断才是最佳的方法，但是我个人还是会**先关闭中断，退出的时候再打开，因为我以前印象中吃过这样的亏，但是也不敢完全确定是不是由于这个原因引起的。反正关了定时中断再处理也不会对我系统造成什么影响。
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-4-5 23:10 | 显示全部楼层
mwxpk 发表于 2014-4-5 15:29
哄不会的啊，全是没用教程

是的，正如你所说“哄不会的”，我分享的经验主要是针对初学者，对于像您这样的比较有经验的工程师来说，确实是没用的教程。你批评的有道理，我接受。
回复

收藏343 举报

cjseng 发表于 2014-4-6 00:47 | 显示全部楼层
本帖最后由 cjseng 于 2014-4-6 00:50 编辑
jianhong_wu 发表于 2014-4-5 23:06
其实你说的这些问题之前也有很多人跟我质疑过。
（1）如果不是做实时时钟，我这样的时间精度可以满足绝大 ...


你这样做对系统的影响就是定时周期不确定。你的周期=定时器周期+中断程序运行时间，而中断程序运行时间是不确定的，会因为各种条件变化，忽长忽短。

你要关闭中断，到退出前再打开，否则会吃亏，这是因为你的定时周期经常小于程序运行时间。

比如你那个给下棋计时的程序，定时是很不精确的，累积起来，误差不是一般的大，可能会达到秒级。这是你的程序造成的，实际上完全可以做得更好，在几十秒内，做到毫秒级的误差一点儿问题也没有。

至于时钟芯片，那个误差并不小，一年的误差在几分钟范围内的，用单片机的定时器做，可以做到比时钟芯片更小的误差（可以用程序修正，比如隔上几天，调快或调慢一秒）。
回复

收藏343 举报

评分

参与人数 1威望 +6 收起 理由
dong_abc + 6

查看全部评分

mrguoch 发表于 2014-4-6 11:40 | 显示全部楼层
这个还不错，学习一下
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-4-6 12:00 | 显示全部楼层
cjseng 发表于 2014-4-6 00:47
你这样做对系统的影响就是定时周期不确定。你的周期=定时器周期+中断程序运行时间，而中断程序运行时间是 ...

没错。我的周期=定时器周期+中断程序运行时间，而中断程序运行的时间虽然会因为各种条件变化，忽长忽短，但实际上“忽长”的时候它不会长很多，“忽短”的时候也不会短很多，所以我默认它是固定不会变化的，对于大多数的项目是够用的。我的象棋计数器通过修正比例系数的方法矫正时间后，2个小时内精度可以控制在1秒钟以内，所以我认为这样的精度是绰绰有余了。当然，我相信你还能把精度做得更高。
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-4-6 12:02 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-4-7 08:49 编辑

第三十九节：判断数据头来接收一串数据的串口通用程序框架。

开场白：
上一节讲了判断数据尾的程序框架，但是在大部分的项目中，都是通过判断数据头来接收数据的，这一节要教会大家两个知识点：
第一个：如何在已经接收到的一串数据中解析数据头协议并且提取有效数据。
第二个：无论是判断数据头还是判断数据尾，无论是单片机还是上位机，最好在固定协议前多发送一个填充的无效字节0x00，因为硬件原因，第一个字节往往容易丢失。

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

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

（2）实现功能：

波特率是：9600 。
通讯协议：EB 00 55  XX YY  
加无效填充字节后,上位机实际上应该发送：00  EB 00 55  XX YY
其中第1位00是无效填充字节，防止由于硬件原因丢失第一个字节。
其中第2,3,4位EB 00 55就是数据头
           后2位XX YY就是有效数据
任意时刻，单片机从电脑“串口调试助手”上位机收到的一串数据中，只要此数据中包含关键字EB 00 55 ，并且此关键字后面两个字节的数据XX YY 分别为01 02,那么蜂鸣器鸣叫一声表示接收的数据头和有效数据都是正确的。

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


  2. 


  3. 

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

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


  6. 

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


  8. 

  9. void initial_myself(void);    
    

  10. void initial_peripheral(void);
    

  11. void delay_long(unsigned int uiDelaylong);
    


  12. 


  13. 


  14. 

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

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

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


  18. 

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


  20. 

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

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

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

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

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


  26. 


  27. 

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


  29. 


  30. 


  31. 

  32. void main() 
    

  33.   {
    

  34.    initial_myself();  
    

  35.    delay_long(100);   
    

  36.    initial_peripheral(); 
    

  37.    while(1)  
    

  38.    { 
    

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

  40.    }
    


  41. 

  42. }
    


  43. 


  44. 

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

  46. {
    


  47. 

  48.         
    

  49. /* 注释一：
    

  50.  * 识别一串数据是否已经全部接收完了的原理:
    

  51.  * 在规定的时间里，如果没有接收到任何一个字节数据，那么就认为一串数据被接收完了，然后就进入数据协议
    

  52.  * 解析和处理的阶段。这个功能的实现要配合定时中断，串口中断的程序一起阅读，要理解他们之间的关系。
    

  53.  */
    

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

  55.      {
    


  56. 

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


  58. 


  59. 


  60. 

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


  62. 

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


  64. 

  65. /* 注释二：
    

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

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

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

  69.  */
    

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

  71.             {
    

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

  73.                {
    

  74.                               if(ucRcregBuf[uiRcMoveIndex+3]==0x01&&ucRcregBuf[uiRcMoveIndex+4]==0x02)  //有效数据01 02的判断
    

  75.                                   {
    

  76.                                       uiVoiceCnt=const_voice_short; //蜂鸣器发出声音，说明数据头和有效数据都接收正确
    

  77.                                   }
    

  78.                   break;   //退出循环
    

  79.                }
    

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

  81.            }
    

  82.                                          
    

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

  84.   
    

  85.      }
    

  86.                          
    

  87. }
    


  88. 


  89. 

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

  91. {
    

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

  93.   TR0=0; //关中断
    


  94. 


  95. 

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

  97.   {
    

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

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

  100.   }
    


  101. 

  102.   if(uiVoiceCnt!=0)
    

  103.   {
    

  104.      uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
    

  105.      beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
    


  106. 

  107.   }
    

  108.   else
    

  109.   {
    

  110.      ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
    

  111.      beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
    

  112.   }
    


  113. 


  114. 

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

  116.   TL0=0x0b;
    

  117.   TR0=1;  //开中断
    

  118. }
    


  119. 


  120. 

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

  122. {        
    


  123. 

  124.    if(RI==1)  
    

  125.    {
    

  126.         RI = 0;
    


  127. 

  128.             ++uiRcregTotal;
    

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

  130.         {
    

  131.            uiRcregTotal=const_rc_size;
    

  132.         }
    

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

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

  135.     
    

  136.    }
    

  137.    else  //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
    

  138.    {
    

  139.         TI = 0;
    

  140.    }
    

  141.                                                          
    

  142. }                                
    


  143. 


  144. 

  145. void delay_long(unsigned int uiDelayLong)
    

  146. {
    

  147.    unsigned int i;
    

  148.    unsigned int j;
    

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

  150.    {
    

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

  152.           {
    

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

  154.           }
    

  155.    }
    

  156. }
    


  157. 


  158. 

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

  160. {
    


  161. 

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


  163. 

  164.   //配置定时器
    

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

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

  167.   TL0=0x0b;
    


  168. 


  169. 

  170.   //配置串口
    

  171.   SCON=0x50;
    

  172.   TMOD=0X21;
    

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

  174.   TR1=1;
    


  175. 

  176. }
    


  177. 

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

  179. {
    


  180. 

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

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

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

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


  185. 

  186. }

总结陈词：
     这一节讲了常用的判断数据头来接收一串数据的程序框架，但是在很多项目中，仅仅靠判断数据头还是不够的，必须要有更加详细的通讯协议，比如可以包含数据类型，有效数据长度，有效数据，数据校验的通讯协议。这样的程序该怎么写？欲知详情，请听下回分解-----常用的自定义串口通讯协议。

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

收藏343 举报

wuzx-61 发表于 2014-4-6 15:27 | 显示全部楼层
顶楼主对初学者的贡献!......
回复

收藏343 举报

gyh974 发表于 2014-4-6 16:49 | 显示全部楼层
好文
回复

收藏343 举报

风雪天殇 发表于 2014-4-6 17:42 | 显示全部楼层
曾经在某个论坛上看过吴老师对单片机和嵌入式系统的理解，很强
回复

收藏343 举报

zxcscm 发表于 2014-4-6 22:22 | 显示全部楼层
收益匪浅啊，希望楼主前辈能继续更新下去！
回复

收藏343 举报

狼牙0354 发表于 2014-4-7 08:25 | 显示全部楼层
其实还是蛮不错的
回复

收藏343 举报

ahczqmz 发表于 2014-4-7 08:30 | 显示全部楼层
:lol
回复

收藏343 举报

sdwflzg 发表于 2014-4-7 10:25 | 显示全部楼层
确实讲得不错！开卷有益！
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-4-7 13:06 | 显示全部楼层
本帖最后由 jianhong_wu 于 2014-7-21 00:05 编辑

第四十节：常用的自定义串口通讯协议。

开场白：
上一节讲了判断数据头的程序框架，但是在很多项目中，仅仅靠判断数据头还是不够的，必须要有更加详细的通讯协议，比如可以包含数据类型，数据地址，有效数据长度，有效数据，数据校验的通讯协议。这一节要教会大家三个知识点：
第一个：常用自定义串口通讯协议的程序框架。
第二个：累加校验和的校验方法。累加和的意思是前面所有字节的数据相加，超过一个字节的溢出部分会按照固定的规则自动丢弃，不用我们管。比如以下数据：
      eb 00 55 01 00 02 0028 6b  
      其中eb 00 55为数据头，01为数据类型，00 02为有效数据长度，00 28 分别为具体的有效数据，6b为前面所有字节的累加和。累加和可以用电脑系统自带的计算器来验证。打开电脑上的计算器，点击“查看”下拉的菜单，选“科学型”，然后选左边的“十六进制”，最后选右边的“字节”，然后把前面所有的字节相加，它们的和就是6b，没错吧。
第三个：原子锁的使用方法，实际上是借鉴了"红金龙吸味"关于原子锁的建议，专门用来保护中断与主函数的共享数据。

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

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

（2）实现功能：
  波特率是：9600.
通讯协议：EB 00 55  GG HH HH XX XX …YYYY CY
其中第1,2,3位EB 00 55就是数据头
其中第4位GG就是数据类型。01代表驱动奉命，02代表驱动Led灯。
其中第5,6位HH就是有效数据长度。高位在左，低位在右。
其中第5,6位HH就是有效数据长度。高位在左，低位在右。
其中从第7位开始，到最后一个字节Cy之前，XX..YY都是具体的有效数据。
在本程序中，当数据类型是01时，有效数据代表蜂鸣器鸣叫的时间长度。当数据类型是02时，有效数据代表Led灯点亮的时间长度。
最后一个字节CY是累加和，前面所有字节的累加。
发送以下测试数据，将会分别控制蜂鸣器和Led灯的驱动时间长度。
蜂鸣器短叫发送：eb 00 55 01 00 02 00 28 6b  
蜂鸣器长叫发送：eb 00 55 01 00 02 00 fa 3d  
Led灯短亮发送：eb 00 55 02 00 02 00 28 6c
Led灯长亮发送：eb 00 55 02 00 02 00 fa3e  

（3）源代码讲解如下：

复制
  1. #include "REG52.H"
    


  2. 

  3. /* 注释一：
    

  4.  * 请评估实际项目中一串数据的最大长度是多少，并且留点余量，然后调整const_rc_size的大小。
    

  5.  * 本节程序把上一节的缓冲区数组大小10改成了20
    

  6.  */
    

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


  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. 


  15. 


  16. 

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

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

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

  20. void led_service(void);  //Led灯的服务程序。
    


  21. 

  22. sbit led_dr=P3^5;  //Led的驱动IO口
    

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


  24. 

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

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

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

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

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

  30. /* 注释二：
    

  31.  * 为串口计时器多增加一个原子锁，作为中断与主函数共享数据的保护，实际上是借鉴了"红金龙吸味"关于原子锁的建议.
    

  32.  */
    

  33. unsigned char  ucSendCntLock=0; //串口计时器的原子锁
    


  34. 

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


  36. 

  37. unsigned char  ucVoiceLock=0;  //蜂鸣器鸣叫的原子锁
    


  38. 

  39. unsigned char ucRcType=0;  //数据类型
    

  40. unsigned int  uiRcSize=0;  //数据长度
    

  41. unsigned char ucRcCy=0;  //校验累加和
    


  42. 

  43. unsigned int  uiRcVoiceTime=0;  //蜂鸣器发出声音的持续时间
    


  44. 

  45. unsigned int  uiRcLedTime=0; //在串口服务程序中，Led灯点亮时间长度的中间变量
    

  46. unsigned int  uiLedTime=0;  //Led灯点亮时间的长度
    

  47. unsigned int  uiLedCnt=0;   //Led灯点亮的计时器
    

  48. unsigned char ucLedLock=0;  //Led灯点亮时间的原子锁
    


  49. 

  50. void main() 
    

  51.   {
    

  52.    initial_myself();  
    

  53.    delay_long(100);   
    

  54.    initial_peripheral(); 
    

  55.    while(1)  
    

  56.    { 
    

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

  58.        led_service(); //Led灯的服务程序
    

  59.    }
    


  60. 

  61. }
    


  62. 

  63. void led_service(void)
    

  64. {
    

  65.    if(uiLedCnt<uiLedTime)
    

  66.    {
    

  67.       led_dr=1; //开Led灯
    

  68.    }
    

  69.    else
    

  70.    {
    

  71.       led_dr=0; //关Led灯
    

  72.    }
    

  73. }
    


  74. 

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

  76. {
    

  77. /* 注释三：
    

  78.  * 我借鉴了朱兆祺的变量命名习惯，单个字母的变量比如i,j,k,h，这些变量只用作局部变量，直接在函数内部定义。
    

  79.  */
    

  80.      unsigned int i;  
    

  81.         
    

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

  83.      {
    


  84. 

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


  86. 


  87. 


  88. 

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


  90. 

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


  92. 


  93. 

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

  95.             {
    

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

  97.                {
    

  98.                          ucRcType=ucRcregBuf[uiRcMoveIndex+3];   //数据类型  一个字节
    


  99. 

  100.                                          uiRcSize=ucRcregBuf[uiRcMoveIndex+4];   //数据长度  两个字节
    

  101.                                          uiRcSize=uiRcSize<<8;
    

  102.                                          uiRcSize=uiRcSize+ucRcregBuf[uiRcMoveIndex+5];
    

  103.                                                                  
    

  104.                                          ucRcCy=ucRcregBuf[uiRcMoveIndex+6+uiRcSize];   //记录最后一个字节的校验 
    

  105.                      ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=0;  //清零最后一个字节的累加和变量
    

  106. /* 注释四：
    

  107.  * 计算校验累加和的方法:除了最后一个字节，其它前面所有的字节累加起来，
    

  108.  * 溢出的不用我们管,C语言编译器会按照固定的规则自动处理。
    

  109.  * 以下for循环里的(3+1+2+uiRcSize)，其中3代表3个字节数据头，1代表1个字节数据类型，
    

  110.  * 2代表2个字节的数据长度变量，uiRcSize代表实际上一串数据中的有效数据个数。
    

  111.  */
    

  112.                                           for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
    

  113.                                          {
    

  114.                                                  ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[uiRcMoveIndex+i];
    

  115.                      }        
    


  116. 


  117. 

  118.                                          if(ucRcCy==ucRcregBuf[uiRcMoveIndex+6+uiRcSize])  //如果校验正确，则进入以下数据处理
    

  119.                                          {                                                  
    

  120.                          switch(ucRcType)   //根据不同的数据类型来做不同的数据处理
    

  121.                                              {
    


  122. 

  123.                              case 0x01:   //驱动蜂鸣器发出声音，并且可以控制蜂鸣器持续发出声音的时间长度
    

  124.         
    

  125.                                   uiRcVoiceTime=ucRcregBuf[uiRcMoveIndex+6];  //把两个字节合并成一个int类型的数据
    

  126.                                   uiRcVoiceTime=uiRcVoiceTime<<8;  
    

  127.                                   uiRcVoiceTime=uiRcVoiceTime+ucRcregBuf[uiRcMoveIndex+7];
    


  128. 

  129.                                   ucVoiceLock=1;  //共享数据的原子锁加锁
    

  130.                                   uiVoiceCnt=uiRcVoiceTime; //蜂鸣器发出声音
    

  131.                                   ucVoiceLock=0;  //共享数据的原子锁解锁
    


  132. 

  133.                                                               break;        
    

  134.                                                                         
    

  135.                              case 0x02:   //点亮一个LED灯，并且可以控制LED灯持续亮的时间长度
    

  136.                                   uiRcLedTime=ucRcregBuf[uiRcMoveIndex+6];  //把两个字节合并成一个int类型的数据
    

  137.                                   uiRcLedTime=uiRcLedTime<<8;  
    

  138.                                   uiRcLedTime=uiRcLedTime+ucRcregBuf[uiRcMoveIndex+7];
    


  139. 

  140.                                   ucLedLock=1;  //共享数据的原子锁加锁
    

  141.                                   uiLedTime=uiRcLedTime; //更改点亮Led灯的时间长度
    

  142.                                                                   uiLedCnt=0;  //在本程序中，清零计数器就等于自动点亮Led灯
    

  143.                                   ucLedLock=0;  //共享数据的原子锁解锁
    

  144.                                                               break;
    

  145.                                                                          
    

  146.                          }
    


  147. 

  148.                                          }        
    


  149. 

  150.                      break;   //退出循环
    

  151.                }
    

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

  153.            }
    

  154.                                          
    

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

  156.   
    

  157.      }
    

  158.                          
    

  159. }
    


  160. 


  161. 

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

  163. {
    

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

  165.   TR0=0; //关中断
    


  166. 

  167.  /* 注释五：
    

  168.   * 此处多增加一个原子锁，作为中断与主函数共享数据的保护，实际上是借鉴了"红金龙吸味"关于原子锁的建议.
    

  169.   */  
    

  170.   if(ucSendCntLock==0)  //原子锁判断
    

  171.   {
    

  172.      ucSendCntLock=1; //加锁
    

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

  174.      {
    

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

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

  177.      }
    

  178.      ucSendCntLock=0; //解锁
    

  179.   }
    


  180. 

  181.   if(ucVoiceLock==0) //原子锁判断
    

  182.   {
    

  183.      if(uiVoiceCnt!=0)
    

  184.      {
    


  185. 

  186.         uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
    

  187.         beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
    

  188.      
    

  189.      }
    

  190.      else
    

  191.      {
    


  192. 

  193.         ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
    

  194.         beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
    

  195.         
    

  196.      }
    

  197.   }
    


  198. 

  199.   if(ucLedLock==0)  //原子锁判断
    

  200.   {
    

  201.      if(uiLedCnt<uiLedTime)
    

  202.          {
    

  203.             uiLedCnt++;  //Led灯点亮的时间计时器
    

  204.          }
    

  205.   }
    


  206. 

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

  208.   TL0=0x0b;
    

  209.   TR0=1;  //开中断
    

  210. }
    


  211. 


  212. 

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

  214. {        
    


  215. 

  216.    if(RI==1)  
    

  217.    {
    

  218.         RI = 0;
    


  219. 

  220.             ++uiRcregTotal;
    

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

  222.         {
    

  223.            uiRcregTotal=const_rc_size;
    

  224.         }
    

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


  226. 

  227.         if(ucSendCntLock==0)  //原子锁判断
    

  228.         {
    

  229.             ucSendCntLock=1; //加锁
    

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

  231.                     ucSendCntLock=0; //解锁
    

  232.                 }
    

  233.     
    

  234.    }
    

  235.    else  //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
    

  236.    {
    

  237.         TI = 0;
    

  238.    }
    

  239.                                                          
    

  240. }                                
    


  241. 


  242. 

  243. void delay_long(unsigned int uiDelayLong)
    

  244. {
    

  245.    unsigned int i;
    

  246.    unsigned int j;
    

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

  248.    {
    

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

  250.           {
    

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

  252.           }
    

  253.    }
    

  254. }
    


  255. 


  256. 

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

  258. {
    

  259.   led_dr=0; //关Led灯
    

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


  261. 

  262.   //配置定时器
    

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

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

  265.   TL0=0x0b;
    


  266. 


  267. 

  268.   //配置串口
    

  269.   SCON=0x50;
    

  270.   TMOD=0X21;
    

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

  272.   TR1=1;
    


  273. 

  274. }
    


  275. 

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

  277. {
    


  278. 

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

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

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

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


  283. 

  284. }

总结陈词：
这一节讲了常用的自定义串口通讯协议的程序框架，这种框架在判断一串数据是否接收完毕的时候，都是靠“超过规定的时间内，没有发现串口数据”来判定的，这是我做绝大多数项目的串口程序框架，但是在少数要求实时反应非常快的项目中，我会用另外一种响应速度更快的串口程序框架，这种程序框架是什么样的？欲知详情，请听下回分解-----在串口接收中断里即时解析数据头的特殊程序框架。

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

收藏343 举报

sdwflzg 发表于 2014-4-14 08:26 | 显示全部楼层
每天学一课，受益匪浅
回复

收藏343 举报

290813633 发表于 2014-4-15 18:58 | 显示全部楼层
zhitao2072 发表于 2014-3-15 11:23
顶起来。。。。。。。

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS厉害
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-4-19 11:43 | 显示全部楼层
第四十一节：在串口接收中断里即时解析数据头的特殊程序框架。

开场白：
上一节讲了常用的自定义串口通讯协议的程序框架，这种框架在判断一串数据是否接收完毕的时候，都是靠“超过规定的时间内，没有发现串口数据”来判定的，这是我做绝大多数项目的串口程序框架，但是在少数要求实时反应非常快的项目中，这样的程序框架可能会满足不了系统对速度的要求，这一节就是要介绍另外一种响应速度更加快的串口程序框架，要教会大家一个知识点：在串口接收中断里即时解析数据头的特殊程序框架。我在这种程序框架里，会尽量简化数据头和数据尾，同时也简化校验，目的都是为了提高响应速度。
具体内容，请看源代码讲解。

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

（2）实现功能：
  波特率是：9600.
通讯协议：EB  GG XX XX XX XX ED
其中第1位EB就是数据头.
其中第2位GG就是数据类型。01代表驱动蜂鸣器，02代表驱动Led灯。
其中第3,4,5,6位XX就是有效数据长度。高位在左，低位在右。
其中第7位ED就是数据尾，在这里也起一部分校验的作用，虽然不是累加和的方式。

在本程序中，
当数据类型是01时，4个有效数据代表一个long类型数据，如果这个数据等于十进制的123456789，那么蜂鸣器就鸣叫一声表示正确。
当数据类型是02时，4个有效数据代表一个long类型数据，如果这个数据等于十进制的123456789，那么LED灯就会闪烁一下表示正确。
十进制的123456789等于十六进制的75bcd15 。
发送以下测试数据，将会分别控制蜂鸣器Led灯。
控制蜂鸣器发送：eb 01 07 5b cd 15 ed
控制LED灯发送：eb 02 07 5b cd 15 ed

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


  2. 


  3. 

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

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


  6. 

  7. #define const_voice_short  80   //蜂鸣器短叫的持续时间
    

  8. #define const_led_short  80    //LED灯亮的持续时间
    


  9. 

  10. void initial_myself(void);    
    

  11. void initial_peripheral(void);
    

  12. void delay_long(unsigned int uiDelaylong);
    


  13. 


  14. 


  15. 

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

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

  18. void led_service(void);  //Led灯的服务程序。
    


  19. 

  20. sbit led_dr=P3^5;  //Led的驱动IO口
    

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


  22. 


  23. 

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

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


  26. 

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

  28. unsigned char  ucVoiceLock=0;  //蜂鸣器鸣叫的原子锁
    


  29. 


  30. 


  31. 

  32. unsigned int  uiRcVoiceTime=0;  //蜂鸣器发出声音的持续时间
    


  33. 

  34. unsigned int  uiLedCnt=0;   //Led灯点亮的计时器
    

  35. unsigned char ucLedLock=0;  //Led灯点亮时间的原子锁
    


  36. 

  37. unsigned long ulBeepData=0; //蜂鸣器的数据
    

  38. unsigned long ulLedData=0; //LED的数据
    


  39. 

  40. unsigned char ucUsartStep=0; //串口接收字节的步骤变量
    


  41. 

  42. void main() 
    

  43.   {
    

  44.    initial_myself();  
    

  45.    delay_long(100);   
    

  46.    initial_peripheral(); 
    

  47.    while(1)  
    

  48.    { 
    

  49.        led_service(); //Led灯的服务程序
    

  50.    }
    


  51. 

  52. }
    


  53. 

  54. void led_service(void)
    

  55. {
    

  56.    if(uiLedCnt<const_led_short)
    

  57.    {
    

  58.       led_dr=1; //开Led灯
    

  59.    }
    

  60.    else
    

  61.    {
    

  62.       led_dr=0; //关Led灯
    

  63.    }
    

  64. }
    


  65. 


  66. 


  67. 

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

  69. {
    

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

  71.   TR0=0; //关中断
    


  72. 

  73.  /* 注释一：
    

  74.   * 此处多增加一个原子锁，作为中断与主函数共享数据的保护，实际上是借鉴了"红金龙吸味"关于原子锁的建议.
    

  75.   */  
    


  76. 

  77.   if(ucVoiceLock==0) //原子锁判断
    

  78.   {
    

  79.      if(uiVoiceCnt!=0)
    

  80.      {
    


  81. 

  82.         uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
    

  83.         beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
    

  84.      
    

  85.      }
    

  86.      else
    

  87.      {
    


  88. 

  89.         ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
    

  90.         beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
    

  91.         
    

  92.      }
    

  93.   }
    


  94. 

  95.   if(ucLedLock==0)  //原子锁判断
    

  96.   {
    

  97.      if(uiLedCnt<const_led_short)
    

  98.      {
    

  99.             uiLedCnt++;  //Led灯点亮的时间计时器
    

  100.      }
    


  101. 

  102.   }
    


  103. 

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

  105.   TL0=0x0b;
    

  106.   TR0=1;  //开中断
    

  107. }
    


  108. 


  109. 

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

  111. {        
    

  112.  /* 注释二：
    

  113.   * 以下就是吴坚鸿在串口接收中断里即时解析数据头的特殊程序框架，
    

  114.   * 它的特点是靠数据头来启动接受有效数据，靠数据尾来识别一串数据接受完毕，
    

  115.   * 这里的数据尾也起到一部分的校验作用，让数据更加可靠。这种程序结构适合应用
    

  116.   * 在传输的数据长度不是很长，而且要求响应速度非常高的实时场合。在这种实时要求
    

  117.   * 非常高的场合中，我就不像之前一样做数据累加和的复杂运算校验，只用数据尾来做简单的
    

  118.   * 校验确认，目的是尽可能提高处理速度。
    

  119.   */  
    


  120. 

  121.    if(RI==1)  
    

  122.    {
    

  123.         RI = 0;
    


  124. 

  125.         switch(ucUsartStep) //串口接收字节的步骤变量
    

  126.         {
    

  127.             case 0:
    

  128.                              ucRcregBuf[0]=SBUF;     
    

  129.                  if(ucRcregBuf[0]==0xeb)  //数据头判断
    

  130.                  {
    

  131.                                      ucRcregBuf[0]=0;  //数据头及时清零，为下一串数据的接受判断做准备
    

  132.                                      uiRcregTotal=1;  //缓存数组的下标初始化
    

  133.                      ucUsartStep=1;  //如果数据头正确，则切换到下一步，依次把上位机来的数据存入数组缓冲区
    

  134.                  }
    

  135.                  break;
    

  136.             case 1:
    

  137.                              ucRcregBuf[uiRcregTotal]=SBUF;  //依次把上位机来的数据存入数组缓冲区
    

  138.                                  uiRcregTotal++; //下标移动
    

  139.                                  if(uiRcregTotal>=7)  //已经接收了7个字节
    

  140.                                  {
    

  141.                    if(ucRcregBuf[6]==0xed)  //数据尾判断，也起到一部分校验的作用，让数据更加可靠,虽然没有用到累加和的检验方法
    

  142.                                    {
    

  143.                                        ucRcregBuf[6]=0;  //数据尾及时清零，为下一串数据的接受判断做准备                                       
    

  144.                                        switch(ucRcregBuf[1]) //根据不同的数据类型来做不同的数据处理
    

  145.                                            {
    

  146.                                                case 0x01:  //与蜂鸣器相关
    

  147.                                 ulBeepData=ucRcregBuf[2]; //把四个字节的数据合并成一个long型的数据
    

  148.                                                             ulBeepData=ulBeepData<<8;
    

  149.                                                             ulBeepData=ulBeepData+ucRcregBuf[3];
    

  150.                                                             ulBeepData=ulBeepData<<8;
    

  151.                                                             ulBeepData=ulBeepData+ucRcregBuf[4];
    

  152.                                                             ulBeepData=ulBeepData<<8;
    

  153.                                                             ulBeepData=ulBeepData+ucRcregBuf[5];
    

  154.                                                                 if(ulBeepData==123456789)  //如果此数据等于十进制的123456789，表示数据正确
    

  155.                                                                 {
    

  156.                                                                     ucVoiceLock=1;  //共享数据的原子锁加锁
    

  157.                                     uiVoiceCnt=const_voice_short; //蜂鸣器发出声音
    

  158.                                     ucVoiceLock=0;  //共享数据的原子锁解锁
    

  159.                                                                 }
    


  160. 

  161.                                                         break;
    


  162. 

  163.                                                case 0x02:  //与Led灯相关
    

  164.                                 ulLedData=ucRcregBuf[2]; //把四个字节的数据合并成一个long型的数据
    

  165.                                                             ulLedData=ulLedData<<8;
    

  166.                                                             ulLedData=ulLedData+ucRcregBuf[3];
    

  167.                                                             ulLedData=ulLedData<<8;
    

  168.                                                             ulLedData=ulLedData+ucRcregBuf[4];
    

  169.                                                             ulLedData=ulLedData<<8;
    

  170.                                                             ulLedData=ulLedData+ucRcregBuf[5];
    

  171.                                                                 if(ulLedData==123456789)  //如果此数据等于十进制的123456789，表示数据正确
    

  172.                                                                 {
    

  173.                                                                     ucLedLock=1;  //共享数据的原子锁加锁
    

  174.                                     uiLedCnt=0;  //在本程序中，清零计数器就等于自动点亮Led灯
    

  175.                                     ucLedLock=0;  //共享数据的原子锁解锁
    

  176.                                                                 }
    


  177. 


  178. 


  179. 

  180.                                                         break;
    

  181.                                            }
    


  182. 

  183.                                    }
    


  184. 

  185.                    ucUsartStep=0;     //返回上一步数据头判断，为下一次的新数据接收做准备
    

  186.                                  }
    

  187.                  break;
    

  188.         }
    

  189.     
    

  190.    }
    

  191.    else  //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
    

  192.    {
    

  193.         TI = 0;
    

  194.    }
    

  195.                                                          
    

  196. }                                
    


  197. 


  198. 

  199. void delay_long(unsigned int uiDelayLong)
    

  200. {
    

  201.    unsigned int i;
    

  202.    unsigned int j;
    

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

  204.    {
    

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

  206.           {
    

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

  208.           }
    

  209.    }
    

  210. }
    


  211. 


  212. 

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

  214. {
    

  215.   led_dr=0; //关Led灯
    

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


  217. 

  218.   //配置定时器
    

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

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

  221.   TL0=0x0b;
    


  222. 


  223. 

  224.   //配置串口
    

  225.   SCON=0x50;
    

  226.   TMOD=0X21;
    

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

  228.   TR1=1;
    


  229. 

  230. }
    


  231. 

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

  233. {
    


  234. 

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

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

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

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


  239. 

  240. }
总结陈词：
    前面花了4节内容仔细讲了各种串口接收数据的常用框架，从下一节开始，我开始讲串口发送数据的程序框架，这种程序框架是什么样的？欲知详情，请听下回分解-----通过串口用delay延时方式发送一串数据。

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

收藏343 举报

cjseng 发表于 2014-4-19 14:58 | 显示全部楼层
唉！把数据处理放在串口中断里，数据量不大还好，要是一次接收上百个字节怎么办呢？这边还没处理完，那边又有新的数据进来了，要丢数据的啊。

还有，为什么 TI=0; 不这样做的话，岂不是要一直进入串口中断？
回复

收藏343 举报

 楼主| jianhong_wu 发表于 2014-4-19 16:14 | 显示全部楼层
cjseng 发表于 2014-4-19 14:58
唉！把数据处理放在串口中断里，数据量不大还好，要是一次接收上百个字节怎么办呢？这边还没处理完，那边又 ...

(1)你说的没错，把数据处理放在串口中断里，只适合数据量小的情况下。如果数据量大的话，请参考我第40节的内容。
(2)感谢你的提醒，让我终于想起来为什么要加TI=0了,就是为了及时清除发送数据产生的中断。
回复

收藏343 举报

cjseng 发表于 2014-4-19 20:51 | 显示全部楼层
jianhong_wu 发表于 2014-4-19 16:14
(1)你说的没错，把数据处理放在串口中断里，只适合数据量小的情况下。如果数据量大的话，请参考我第40节 ...

你前边用的那种方法也不一定能处理大数据量的串口通讯，除非你事先知道每两帧数据之间的间隔时间的大小。
要确保通讯可靠，除了硬件，完善的协议很重要。你还不如参考一下MODBUS通讯协议呢。
回复

收藏343 举报

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

本版积分规则

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