您的位置 首页 IOT

第44节：从机的串口收发归纳程序结构

2020年9月18日 14:41 阅读(222)

开场白：根据上一节的预告，本来这一节内容打算讲利用AT24C02进行掉电后的数据保存的，但是由于网友261854681强烈建议我讲一个完整的串口收

开场白：
依据上一节的预告，原本这一节内容计划讲“使用AT24C02进行掉电后的数据保存”的，可是由于网友“261854681”强烈主张我讲一个完好的串口收发程序实例，因而我决议再花两节篇幅讲讲这方面的内容。
实践上在大部分的项目中，串口都需求“一收一应对”的握手协议，上位机作为主机，单片机作为从机，主机先发一串数据，从机收到数据后进行校验判别，假如校验正确则回来正确应对指令，假如校验过错则回来过错应对指令，主机收到应对指令后，假如发现是正确应对指令则持续发送其它的新数据，假如发现是过错应对指令，或许超时没有接纳到任何应对指令，则持续重发，假如接连重发三次都是过错应对或许无应对，主机就进行报错处理。
这节先讲从机的收发端程序实例。要教会我们三个知识点：
榜首个：为了确保串口中止接纳的数据不丢掉，在初始化时有必要设置IP = 0x10，相当于把串口中止设置为最高优先级，这个时分，串口中止能够打断任何其他的中止服务函数，完结中止嵌套。
第二个：从机端的收发端程序结构。
第三个：从机的状况指示程序结构。能够指示待机，通讯中，超时犯错三种状况。

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

（1）硬件渠道：
依据朱兆祺51单片机学习板。

（2）完结功用：
显现和独立按键部分依据第29节的程序来改编，用朱兆祺51单片机学习板中的S1,S5,S9,S13作为独立按键。
一共有4个窗口。每个窗口显现一个参数。有两种更改参数的方法：
榜首种：按键更改参数：
第8,7,6,5位数码管显现当时窗口，P-1代表第1个窗口，P-2代表第2个窗口，P-3代表第3个窗口，P-4代表第1个窗口。
第4,3,2,1位数码管显现当时窗口被设置的参数。规模是从0到9999。S1是加按键，按下此按键会顺次添加当时窗口的参数。S5是减按键，按下此按键会顺次削减当时窗口的参数。S9是切换窗口按键，按下此按键会顺次循环切换不同的窗口。S13是复位按键，当通讯超时蜂鸣器报警时，能够按下此键铲除报警。

第二种：通过串口来更改参数：
波特率是：9600.
通讯协议：EB 00 55GG 00 02 XX XXCY
其间第1,2,3位EB 00 55便是数据头
其间第4位GG便是数据类型。01代表更改参数1，02代表更改参数2，03代表更改参数3，04代表更改参数4，
其间第5,6位00 02便是有用数据长度。高位在左，低位在右。
其间从第7，8位XX XX是被更改的参数。高位在左，低位在右。
第9位CY是累加和，前面一切字节的累加。
一个完好的通讯有必要接纳完4串数据，每串数据之间的间隔时刻不能超越10秒钟，不然以为通讯超时犯错引发蜂鸣器报警。假如接纳到得数据校验正确，
则回来校验正确应对：eb 00 55 f5 00 00 35，
不然回来校验犯错应对:：eb 00 55 fa 00 00 3a。
体系处于待机状况时，LED灯一向亮，
体系处于非待机状况时，LED灯闪耀，
体系处于通讯超时犯错状况时，LED灯闪耀，而且蜂鸣器间歇鸣叫报警。

通过电脑的串口帮手，顺次发送以下测试数据，将会别离更改参数1，参数2，参数3，参数4。留意，每串数据之间的时刻最大不能超越10秒，不然体系以为通讯超时报警。
把参数1更改为十进制的1： eb 00 55 01 00 02 00 01 44
把参数2更改为十进制的12：eb 00 55 02 00 02 00 0c 50
把参数3更改为十进制的123： eb 00 55 03 00 02 00 7b c0
把参数4更改为十进制的1234：eb 00 55 04 00 02 04 d2 1c

（3）源代码解说如下：

  1. #include “REG52.H”
  3. #define const_voice_short40 //蜂鸣器短叫的持续时刻
  4. #define const_key_time120 //按键去颤动延时的时刻
  5. #define const_key_time220 //按键去颤动延时的时刻
  6. #define const_key_time320 //按键去颤动延时的时刻
  7. #define const_key_time420 //按键去颤动延时的时刻
  9. #define const_led_0_5s200 //大约0.5秒的时刻
  10. #define const_led_1s 400 //大约1秒的时刻
  12. #define const_send_time_out 4000//通讯超时犯错的时刻 大约10秒
  14. #define const_rc_size20//接纳串口中止数据的缓冲区数组巨细
  15. #define const_receive_time5//假如超越这个时刻没有串口数据过来，就以为一串数据现已悉数接纳完，这个时刻依据实践情况来调整巨细
  17. #define const_send_size10//串口发送数据的缓冲区数组巨细
  19. void initial_myself(void);
  20. void initial_peripheral(void);
  21. void delay_short(unsigned int uiDelayShort);
  22. void delay_long(unsigned int uiDelaylong);
  23. //驱动数码管的74HC595
  24. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
  25. void display_drive(void); //显现数码管字模的驱动函数
  26. void display_service(void); //显现的窗口菜单服务程序
  27. //驱动LED的74HC595
  28. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
  30. void T0_time(void);//守时中止函数
  31. void usart_receive(void); //串口接纳中止函数
  32. void usart_service(void);//串口服务程序,在main函数里
  33. void eusart_send(unsigned char ucSendData); //发送一个字节，内部自带每个字节之间的delay延时
  35. void key_service(void); //按键服务的应用程序
  36. void key_scan(void);//按键扫描函数 放在守时中止里
  38. void status_service(void);//状况显现的应用程序
  41. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  42. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  43. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
  44. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
  45. sbit key_gnd_dr=P0^4; //模仿独立按键的地GND，因而有必要一向输出低电平
  46. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  47. sbit led_dr=P3^5;//作为状况指示灯 亮的时分表明待机状况.闪耀表明非待机状况，处于正在发送数据或许犯错的状况
  49. sbit dig_hc595_sh_dr=P2^0; //数码管的74HC595程序
  50. sbit dig_hc595_st_dr=P2^1;
  51. sbit dig_hc595_ds_dr=P2^2;
  52. sbit hc595_sh_dr=P2^3; //LED灯的74HC595程序
  53. sbit hc595_st_dr=P2^4;
  54. sbit hc595_ds_dr=P2^5;
  56. unsigned char ucSendregBuf[const_send_size]; //发送的缓冲区数组
  58. unsigned intuiSendCnt=0; //用来辨认串口是否接纳完一串数据的计时器
  59. unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接纳完一串数据只处理一次
  60. unsigned intuiRcregTotal=0;//代表当时缓冲区现已接纳了多少个数据
  61. unsigned char ucRcregBuf[const_rc_size]; //接纳串口中止数据的缓冲区数组
  62. unsigned intuiRcMoveIndex=0;//用来解析数据协议的中心变量
  64. unsigned charucSendCntLock=0; //串口计时器的原子锁
  65. unsigned char ucRcType=0;//数据类型
  66. unsigned intuiRcSize=0;//数据长度
  67. unsigned char ucRcCy=0;//校验累加和
  69. unsigned intuiLedCnt=0;//操控Led闪耀的延时计时器
  70. unsigned intuiSendTimeOutCnt=0; //用来辨认接纳数据超时的计时器
  71. unsigned char ucSendTimeOutLock=0; //原子锁
  74. unsigned char ucStatus=0; //当时状况变量 0代表待机 1代表正在通讯进程 2代表发送犯错
  76. unsigned char ucKeySec=0; //被触发的按键编号
  78. unsigned intuiKeyTimeCnt1=0; //按键去颤动延时计数器
  79. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
  80. unsigned intuiKeyTimeCnt2=0; //按键去颤动延时计数器
  81. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
  82. unsigned intuiKeyTimeCnt3=0; //按键去颤动延时计数器
  83. unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
  84. unsigned intuiKeyTimeCnt4=0; //按键去颤动延时计数器
  85. unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志
  88. unsigned intuiVoiceCnt=0;//蜂鸣器鸣叫的持续时刻计数器
  89. unsigned charucVoiceLock=0;//蜂鸣器鸣叫的原子锁
  91. unsigned char ucDigShow8;//第8位数码管要显现的内容
  92. unsigned char ucDigShow7;//第7位数码管要显现的内容
  93. unsigned char ucDigShow6;//第6位数码管要显现的内容
  94. unsigned char ucDigShow5;//第5位数码管要显现的内容
  95. unsigned char ucDigShow4;//第4位数码管要显现的内容
  96. unsigned char ucDigShow3;//第3位数码管要显现的内容
  97. unsigned char ucDigShow2;//第2位数码管要显现的内容
  98. unsigned char ucDigShow1;//第1位数码管要显现的内容
  100. unsigned char ucDigDot8;//数码管8的小数点是否显现的标志
  101. unsigned char ucDigDot7;//数码管7的小数点是否显现的标志
  102. unsigned char ucDigDot6;//数码管6的小数点是否显现的标志
  103. unsigned char ucDigDot5;//数码管5的小数点是否显现的标志
  104. unsigned char ucDigDot4;//数码管4的小数点是否显现的标志
  105. unsigned char ucDigDot3;//数码管3的小数点是否显现的标志
  106. unsigned char ucDigDot2;//数码管2的小数点是否显现的标志
  107. unsigned char ucDigDot1;//数码管1的小数点是否显现的标志
  108. unsigned char ucDigShowTemp=0; //暂时中心变量
  109. unsigned char ucDisplayDriveStep=1;//动态扫描数码管的进程变量
  111. unsigned char ucWd1Update=1; //窗口1更新显现标志
  112. unsigned char ucWd2Update=0; //窗口2更新显现标志
  113. unsigned char ucWd3Update=0; //窗口3更新显现标志
  114. unsigned char ucWd4Update=0; //窗口4更新显现标志
  115. unsigned char ucWd=1;//本程序的中心变量，窗口显现变量。类似于一级菜单的变量。代表显现不同的窗口。
  116. unsigned intuiSetData1=0;//本程序中需求被设置的参数1
  117. unsigned intuiSetData2=0;//本程序中需求被设置的参数2
  118. unsigned intuiSetData3=0;//本程序中需求被设置的参数3
  119. unsigned intuiSetData4=0;//本程序中需求被设置的参数4
  121. unsigned char ucTemp1=0;//中心过渡变量
  122. unsigned char ucTemp2=0;//中心过渡变量
  123. unsigned char ucTemp3=0;//中心过渡变量
  124. unsigned char ucTemp4=0;//中心过渡变量
  126. //依据原理图得出的共阴数码管字模表
  127. code unsigned char dig_table[]=
  128. {
  129. 0x3f,//0 序号0
  130. 0x06,//1 序号1
  131. 0x5b,//2 序号2
  132. 0x4f,//3 序号3
  133. 0x66,//4 序号4
  134. 0x6d,//5 序号5
  135. 0x7d,//6 序号6
  136. 0x07,//7 序号7
  137. 0x7f,//8 序号8
  138. 0x6f,//9 序号9
  139. 0x00,//无 序号10
  140. 0x40,//- 序号11
  141. 0x73,//P 序号12
  142. };
  143. void main()
  144. {
  145. initial_myself();
  146. delay_long(100);
  147. initial_peripheral();
  148. while(1)
  149. {
  150. key_service(); //按键服务的应用程序
  151. usart_service();//串口服务程序
  152. display_service(); //显现的窗口菜单服务程序
  153. status_service();//状况显现的应用程序
  154. }
  155. }
  157. void status_service(void)//状况显现的应用程序
  158. {
  159. if(ucStatus!=0) //处于非待机的状况,Led闪耀
  160. {
  161. if(uiLedCnt
  162. {
  163. led_dr=1;//前半秒亮
  165. if(ucStatus==2)//处于发送数据犯错的状况，则蜂鸣器间歇鸣叫报警
  166. {
  167. ucVoiceLock=1;//原子锁加锁，维护主函数与中止函数的同享变量uiVoiceCnt
  168. uiVoiceCnt=const_voice_short; //按键声响触发，滴一声就停。
  169. ucVoiceLock=0;//原子锁解锁，维护主函数与中止函数的同享变量uiVoiceCnt
  170. }
  171. }
  172. else if(uiLedCnt
  173. {
  174. led_dr=0; //前半秒灭
  175. }
  176. else
  177. {
  178. uiLedCnt=0; //延时计时器清零，让Led灯处于闪耀的重复循环中
  179. }
  181. }
  182. else//处于待机状况，Led一向亮
  183. {
  184. led_dr=1;
  186. }
  190. }
  194. void usart_service(void)//串口服务程序,在main函数里
  195. {
  197. unsigned int i;
  199. if(uiSendCnt>=const_receive_time&&ucSendLock==1) //阐明超越了必定的时刻内，再也没有新数据从串口来
  200. {
  202. ucSendLock=0; //处理一次就锁起来，不必每次都进来,除非有新接纳的数据
  203. //下面的代码进入数据协议解析和数据处理的阶段
  205. uiRcMoveIndex=0; //由于是判别数据头，所以下标移动变量从数组的0开端向最尾端移动
  207. while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))
  208. {
  210. if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)//数据头eb 00 55的判别
  211. {
  213. ucRcType=ucRcregBuf[uiRcMoveIndex+3]; //数据类型一个字节
  214. uiRcSize=ucRcregBuf[uiRcMoveIndex+4]; //数据长度两个字节
  215. uiRcSize=uiRcSize<<8;
  216. uiRcSize=uiRcSize+ucRcregBuf[uiRcMoveIndex+5];
  218. ucRcCy=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]; //记载最终一个字节的校验
  219. ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=0;//清零最终一个字节的累加和变量
  221. for(i=0;i<(3+1+2+uiRcSize);i++) //核算校验累加和
  222. {
  223. ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[uiRcMoveIndex+i];
  224. }
  227. if(ucRcCy==ucRcregBuf[uiRcMoveIndex+6+uiRcSize])//假如校验正确，则进入以下数据处理
  228. {
  229. switch(ucRcType) //依据不同的数据类型来做不同的数据处理
  230. {
  231. case 0x01: //设置参数1
  233. ucStatus=1; //从设置参数1开端，表明当时处于正在发送数据的状况
  235. uiSetData1=ucRcregBuf[uiRcMoveIndex+6];//把两个字节合并成一个int类型的数据
  236. uiSetData1=uiSetData1<<8;
  237. uiSetData1=uiSetData1+ucRcregBuf[uiRcMoveIndex+7];
  238. ucWd1Update=1; //窗口1更新显现
  239. break;
  241. case 0x02: //设置参数2
  243. uiSetData2=ucRcregBuf[uiRcMoveIndex+6];//把两个字节合并成一个int类型的数据
  244. uiSetData2=uiSetData2<<8;
  245. uiSetData2=uiSetData2+ucRcregBuf[uiRcMoveIndex+7];
  246. ucWd2Update=1; //窗口2更新显现
  247. break;
  249. case 0x03: //设置参数3
  251. uiSetData3=ucRcregBuf[uiRcMoveIndex+6];//把两个字节合并成一个int类型的数据
  252. uiSetData3=uiSetData3<<8;
  253. uiSetData3=uiSetData3+ucRcregBuf[uiRcMoveIndex+7];
  254. ucWd3Update=1; //窗口3更新显现
  255. break;
  257. case 0x04: //设置参数4
  259. ucStatus=0; //从设置参数4结束发送数据的状况，表明发送数据的进程成功，切换回待机状况
  261. uiSetData4=ucRcregBuf[uiRcMoveIndex+6];//把两个字节合并成一个int类型的数据
  262. uiSetData4=uiSetData4<<8;
  263. uiSetData4=uiSetData4+ucRcregBuf[uiRcMoveIndex+7];
  264. ucWd4Update=1; //窗口4更新显现
  265. break;
  268. }
  271. ucSendregBuf[0]=0xeb; //把预备发送的数据放入发送缓冲区
  272. ucSendregBuf[1]=0x00;
  273. ucSendregBuf[2]=0x55;
  274. ucSendregBuf[3]=0xf5;//代表校验正确
  275. ucSendregBuf[4]=0x00;
  276. ucSendregBuf[5]=0x00;
  277. ucSendregBuf[6]=0x35;
  279. for(i=0;i<7;i++)//回来校验正确的应对指令
  280. {
  281. eusart_send(ucSendregBuf[i]);//发送一串数据给上位机
  282. }
  284. }
  285. else
  286. {
  287. ucSendTimeOutLock=1; //原子锁加锁
  288. uiSendTimeOutCnt=0;//超时计时器计时清零
  289. ucSendTimeOutLock=0; //原子锁解锁
  291. ucSendregBuf[0]=0xeb; //把预备发送的数据放入发送缓冲区
  292. ucSendregBuf[1]=0x00;
  293. ucSendregBuf[2]=0x55;
  294. ucSendregBuf[3]=0xfa; //代表校验过错
  295. ucSendregBuf[4]=0x00;
  296. ucSendregBuf[5]=0x00;
  297. ucSendregBuf[6]=0x3a;
  299. for(i=0;i<7;i++)//回来校验过错的应对指令
  300. {
  301. eusart_send(ucSendregBuf[i]);//发送一串数据给上位机
  302. }
  304. }
  306. ucSendTimeOutLock=1; //原子锁加锁
  307. uiSendTimeOutCnt=0;//超时计时器计时清零
  308. ucSendTimeOutLock=0; //原子锁解锁
  310. break; //退出循环
  311. }
  312. uiRcMoveIndex++; //由于是判别数据头，游标向着数组最尾端的方向移动
  313. }
  315. uiRcregTotal=0;//清空缓冲的下标，便利下次从头从0下标开端承受新数据
  317. }
  319. }
  322. void eusart_send(unsigned char ucSendData) //发送一个字节，内部自带每个字节之间的delay延时
  323. {
  325. ES = 0; //关串口中止
  326. TI = 0; //清零串口发送完结中止请求标志
  327. SBUF =ucSendData; //发送一个字节
  329. delay_short(400);//每个字节之间的延时，这儿十分要害，也是最简单犯错的当地。延时的巨细请依据实践项目来调整
  331. TI = 0; //清零串口发送完结中止请求标志
  332. ES = 1; //答应串口中止
  334. }
  337. void display_service(void) //显现的窗口菜单服务程序
  338. {
  340. switch(ucWd)//本程序的中心变量，窗口显现变量。类似于一级菜单的变量。代表显现不同的窗口。
  341. {
  342. case 1: //显现P–1窗口的数据
  343. if(ucWd1Update==1)//窗口1要悉数更新显现
  344. {
  345. ucWd1Update=0;//及时清零标志，防止一向进来扫描
  346. ucDigShow8=12;//第8位数码管显现P
  347. ucDigShow7=11;//第7位数码管显现-
  348. ucDigShow6=1; //第6位数码管显现1
  349. ucDigShow5=10;//第5位数码管显现无
  351. //先分化数据
  352. ucTemp4=uiSetData1/1000;
  353. ucTemp3=uiSetData1%1000/100;
  354. ucTemp2=uiSetData1%100/10;
  355. ucTemp1=uiSetData1%10;
  357. //再过渡需求显现的数据到缓冲变量里，让过渡的时刻越短越好
  359. if(uiSetData1<1000)
  360. {
  361. ucDigShow4=10;//假如小于1000，千位显现无
  362. }
  363. else
  364. {
  365. ucDigShow4=ucTemp4;//第4位数码管要显现的内容
  366. }
  367. if(uiSetData1<100)
  368. {
  369. ucDigShow3=10;//假如小于100，百位显现无
  370. }
  371. else
  372. {
  373. ucDigShow3=ucTemp3;//第3位数码管要显现的内容
  374. }
  375. if(uiSetData1<10)
  376. {
  377. ucDigShow2=10;//假如小于10，十位显现无
  378. }
  379. else
  380. {
  381. ucDigShow2=ucTemp2;//第2位数码管要显现的内容
  382. }
  383. ucDigShow1=ucTemp1;//第1位数码管要显现的内容
  384. }
  385. break;
  386. case 2://显现P–2窗口的数据
  387. if(ucWd2Update==1)//窗口2要悉数更新显现
  388. {
  389. ucWd2Update=0;//及时清零标志，防止一向进来扫描
  390. ucDigShow8=12;//第8位数码管显现P
  391. ucDigShow7=11;//第7位数码管显现-
  392. ucDigShow6=2;//第6位数码管显现2
  393. ucDigShow5=10; //第5位数码管显现无
  394. ucTemp4=uiSetData2/1000; //分化数据
  395. ucTemp3=uiSetData2%1000/100;
  396. ucTemp2=uiSetData2%100/10;
  397. ucTemp1=uiSetData2%10;
  399. if(uiSetData2<1000)
  400. {
  401. ucDigShow4=10;//假如小于1000，千位显现无
  402. }
  403. else
  404. {
  405. ucDigShow4=ucTemp4;//第4位数码管要显现的内容
  406. }
  407. if(uiSetData2<100)
  408. {
  409. ucDigShow3=10;//假如小于100，百位显现无
  410. }
  411. else
  412. {
  413. ucDigShow3=ucTemp3;//第3位数码管要显现的内容
  414. }
  415. if(uiSetData2<10)
  416. {
  417. ucDigShow2=10;//假如小于10，十位显现无
  418. }
  419. else
  420. {
  421. ucDigShow2=ucTemp2;//第2位数码管要显现的内容
  422. }
  423. ucDigShow1=ucTemp1;//第1位数码管要显现的内容
  424. }
  425. break;
  426. case 3://显现P–3窗口的数据
  427. if(ucWd3Update==1)//窗口3要悉数更新显现
  428. {
  429. ucWd3Update=0;//及时清零标志，防止一向进来扫描
  430. ucDigShow8=12;//第8位数码管显现P
  431. ucDigShow7=11;//第7位数码管显现-
  432. ucDigShow6=3;//第6位数码管显现3
  433. ucDigShow5=10; //第5位数码管显现无
  434. ucTemp4=uiSetData3/1000; //分化数据
  435. ucTemp3=uiSetData3%1000/100;
  436. ucTemp2=uiSetData3%100/10;
  437. ucTemp1=uiSetData3%10;
  438. if(uiSetData3<1000)
  439. {
  440. ucDigShow4=10;//假如小于1000，千位显现无
  441. }
  442. else
  443. {
  444. ucDigShow4=ucTemp4;//第4位数码管要显现的内容
  445. }
  446. if(uiSetData3<100)
  447. {
  448. ucDigShow3=10;//假如小于100，百位显现无
  449. }
  450. else
  451. {
  452. ucDigShow3=ucTemp3;//第3位数码管要显现的内容
  453. }
  454. if(uiSetData3<10)
  455. {
  456. ucDigShow2=10;//假如小于10，十位显现无
  457. }
  458. else
  459. {
  460. ucDigShow2=ucTemp2;//第2位数码管要显现的内容
  461. }
  462. ucDigShow1=ucTemp1;//第1位数码管要显现的内容
  463. }
  464. break;
  465. case 4://显现P–4窗口的数据
  466. if(ucWd4Update==1)//窗口4要悉数更新显现
  467. {
  468. ucWd4Update=0;//及时清零标志，防止一向进来扫描
  469. ucDigShow8=12;//第8位数码管显现P
  470. ucDigShow7=11;//第7位数码管显现-
  471. ucDigShow6=4;//第6位数码管显现4
  472. ucDigShow5=10; //第5位数码管显现无
  473. ucTemp4=uiSetData4/1000; //分化数据
  474. ucTemp3=uiSetData4%1000/100;
  475. ucTemp2=uiSetData4%100/10;
  476. ucTemp1=uiSetData4%10;
  478. if(uiSetData4<1000)
  479. {
  480. ucDigShow4=10;//假如小于1000，千位显现无
  481. }
  482. else
  483. {
  484. ucDigShow4=ucTemp4;//第4位数码管要显现的内容
  485. }
  486. if(uiSetData4<100)
  487. {
  488. ucDigShow3=10;//假如小于100，百位显现无
  489. }
  490. else
  491. {
  492. ucDigShow3=ucTemp3;//第3位数码管要显现的内容
  493. }
  494. if(uiSetData4<10)
  495. {
  496. ucDigShow2=10;//假如小于10，十位显现无
  497. }
  498. else
  499. {
  500. ucDigShow2=ucTemp2;//第2位数码管要显现的内容
  501. }
  502. ucDigShow1=ucTemp1;//第1位数码管要显现的内容
  503. }
  504. break;
  505. }
  508. }
  510. void key_scan(void)//按键扫描函数 放在守时中止里
  511. {
  512. if(key_sr1==1)//IO是高电平，阐明按键没有被按下，这时要及时清零一些标志位
  513. {
  514. ucKeyLock1=0; //按键自锁标志清零
  515. uiKeyTimeCnt1=0;//按键去颤动延时计数器清零，此行十分奇妙，是我实战中探索出来的。
  516. }
  517. else if(ucKeyLock1==0)//有按键按下，且是榜首次被按下
  518. {
  519. uiKeyTimeCnt1++; //累加守时中止次数
  520. if(uiKeyTimeCnt1>const_key_time1)
  521. {
  522. uiKeyTimeCnt1=0;
  523. ucKeyLock1=1;//自锁按键置位,防止一向触发
  524. ucKeySec=1; //触发1号键
  525. }
  526. }
  528. if(key_sr2==1)//IO是高电平，阐明按键没有被按下，这时要及时清零一些标志位
  529. {
  530. ucKeyLock2=0; //按键自锁标志清零
  531. uiKeyTimeCnt2=0;//按键去颤动延时计数器清零，此行十分奇妙，是我实战中探索出来的。
  532. }
  533. else if(ucKeyLock2==0)//有按键按下，且是榜首次被按下
  534. {
  535. uiKeyTimeCnt2++; //累加守时中止次数
  536. if(uiKeyTimeCnt2>const_key_time2)
  537. {
  538. uiKeyTimeCnt2=0;
  539. ucKeyLock2=1;//自锁按键置位,防止一向触发
  540. ucKeySec=2; //触发2号键
  541. }
  542. }
  544. if(key_sr3==1)//IO是高电平，阐明按键没有被按下，这时要及时清零一些标志位
  545. {
  546. ucKeyLock3=0; //按键自锁标志清零
  547. uiKeyTimeCnt3=0;//按键去颤动延时计数器清零，此行十分奇妙，是我实战中探索出来的。
  548. }
  549. else if(ucKeyLock3==0)//有按键按下，且是榜首次被按下
  550. {
  551. uiKeyTimeCnt3++; //累加守时中止次数
  552. if(uiKeyTimeCnt3>const_key_time3)
  553. {
  554. uiKeyTimeCnt3=0;
  555. ucKeyLock3=1;//自锁按键置位,防止一向触发
  556. ucKeySec=3; //触发3号键
  557. }
  558. }
  560. if(key_sr4==1)//IO是高电平，阐明按键没有被按下，这时要及时清零一些标志位
  561. {
  562. ucKeyLock4=0; //按键自锁标志清零
  563. uiKeyTimeCnt4=0;//按键去颤动延时计数器清零，此行十分奇妙，是我实战中探索出来的。
  564. }
  565. else if(ucKeyLock4==0)//有按键按下，且是榜首次被按下
  566. {
  567. uiKeyTimeCnt4++; //累加守时中止次数
  568. if(uiKeyTimeCnt4>const_key_time4)
  569. {
  570. uiKeyTimeCnt4=0;
  571. ucKeyLock4=1;//自锁按键置位,防止一向触发
  572. ucKeySec=4; //触发4号键
  573. }
  574. }
  575. }
  577. void key_service(void) //按键服务的应用程序
  578. {
  580. switch(ucKeySec) //按键服务状况切换
  581. {
  582. case 1:// 加按键 对应朱兆祺学习板的S1键
  583. switch(ucWd)//在不同的窗口下，设置不同的参数
  584. {
  585. case 1:
  586. uiSetData1++;
  587. if(uiSetData1>9999) //最大值是9999
  588. {
  589. uiSetData1=9999;
  590. }
  591. ucWd1Update=1;//窗口1更新显现
  592. break;
  593. case 2:
  594. uiSetData2++;
  595. if(uiSetData2>9999) //最大值是9999
  596. {
  597. uiSetData2=9999;
  598. }
  599. ucWd2Update=1;//窗口2更新显现
  600. break;
  601. case 3:
  602. uiSetData3++;
  603. if(uiSetData3>9999) //最大值是9999
  604. {
  605. uiSetData3=9999;
  606. }
  607. ucWd3Update=1;//窗口3更新显现
  608. break;
  609. case 4:
  610. uiSetData4++;
  611. if(uiSetData4>9999) //最大值是9999
  612. {
  613. uiSetData4=9999;
  614. }
  615. ucWd4Update=1;//窗口4更新显现
  616. break;
  617. }
  619. ucVoiceLock=1;//原子锁加锁，维护主函数与中止函数的同享变量uiVoiceCnt
  620. uiVoiceCnt=const_voice_short; //按键声响触发，滴一声就停。
  621. ucVoiceLock=0;//原子锁解锁，维护主函数与中止函数的同享变量uiVoiceCnt
  623. ucKeySec=0;//呼应按键服务处理程序后，按键编号清零，防止共同触发
  624. break;
  626. case 2:// 减按键 对应朱兆祺学习板的S5键
  627. switch(ucWd)//在不同的窗口下，设置不同的参数
  628. {
  629. case 1:
  630. uiSetData1–;
  632. if(uiSetData1>9999)
  633. {
  634. uiSetData1=0;//最小值是0
  635. }
  636. ucWd1Update=1;//窗口1更新显现
  637. break;
  638. case 2:
  639. uiSetData2–;
  640. if(uiSetData2>9999)
  641. {
  642. uiSetData2=0;//最小值是0
  643. }
  644. ucWd2Update=1;//窗口2更新显现
  645. break;
  646. case 3:
  647. uiSetData3–;
  648. if(uiSetData3>9999)
  649. {
  650. uiSetData3=0;//最小值是0
  651. }
  652. ucWd3Update=1;//窗口3更新显现
  653. break;
  654. case 4:
  655. uiSetData4–;
  656. if(uiSetData4>9999)
  657. {
  658. uiSetData4=0;//最小值是0
  659. }
  660. ucWd4Update=1;//窗口4更新显现
  661. break;
  662. }
  664. ucVoiceLock=1;//原子锁加锁，维护主函数与中止函数的同享变量uiVoiceCnt
  665. uiVoiceCnt=const_voice_short; //按键声响触发，滴一声就停。
  666. ucVoiceLock=0;//原子锁解锁，维护主函数与中止函数的同享变量uiVoiceCnt
  668. ucKeySec=0;//呼应按键服务处理程序后，按键编号清零，防止共同触发
  669. break;
  671. case 3:// 切换窗口按键 对应朱兆祺学习板的S9键
  672. ucWd++;//切换窗口
  673. if(ucWd>4)
  674. {
  675. ucWd=1;
  676. }
  677. switch(ucWd)//在不同的窗口下，在不同的窗口下，更新显现不同的窗口
  678. {
  679. case 1:
  680. ucWd1Update=1;//窗口1更新显现
  681. break;
  682. case 2:
  683. ucWd2Update=1;//窗口2更新显现
  684. break;
  685. case 3:
  686. ucWd3Update=1;//窗口3更新显现
  687. break;
  688. case 4:
  689. ucWd4Update=1;//窗口4更新显现
  690. break;
  691. }
  692. ucVoiceLock=1;//原子锁加锁，维护主函数与中止函数的同享变量uiVoiceCnt
  693. uiVoiceCnt=const_voice_short; //按键声响触发，滴一声就停。
  694. ucVoiceLock=0;//原子锁解锁，维护主函数与中止函数的同享变量uiVoiceCnt
  696. ucKeySec=0;//呼应按键服务处理程序后，按键编号清零，防止共同触发
  697. break;
  699. case 4:// 复位按键 对应朱兆祺学习板的S13键
  700. switch(ucStatus)//在不同的状况下，进行不同的操作
  701. {
  702. case 0://处于待机状况
  703. break;
  705. case 1://处于正在通讯的进程
  706. break;
  708. case 2: //发送数据犯错，比方中心超时没有接纳到数据
  709. ucStatus=0; //切换回待机的状况
  710. break;
  711. }
  712. ucVoiceLock=1;//原子锁加锁，维护主函数与中止函数的同享变量uiVoiceCnt
  713. uiVoiceCnt=const_voice_short; //按键声响触发，滴一声就停。
  714. ucVoiceLock=0;//原子锁解锁，维护主函数与中止函数的同享变量uiVoiceCnt
  716. ucKeySec=0;//呼应按键服务处理程序后，按键编号清零，防止共同触发
  718. break;
  720. }
  721. }
  723. void display_drive(void)
  724. {
  725. //以下程序，假如加一些数组和移位的元素，还能够紧缩容量。可是鸿哥寻求的不是容量，而是明晰的解说思路
  726. switch(ucDisplayDriveStep)
  727. {
  728. case 1://显现第1位
  729. ucDigShowTemp=dig_table[ucDigShow1];
  730. if(ucDigDot1==1)
  731. {
  732. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  733. }
  734. dig_hc595_drive(ucDigShowTemp,0xfe);
  735. break;
  736. case 2://显现第2位
  737. ucDigShowTemp=dig_table[ucDigShow2];
  738. if(ucDigDot2==1)
  739. {
  740. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  741. }
  742. dig_hc595_drive(ucDigShowTemp,0xfd);
  743. break;
  744. case 3://显现第3位
  745. ucDigShowTemp=dig_table[ucDigShow3];
  746. if(ucDigDot3==1)
  747. {
  748. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  749. }
  750. dig_hc595_drive(ucDigShowTemp,0xfb);
  751. break;
  752. case 4://显现第4位
  753. ucDigShowTemp=dig_table[ucDigShow4];
  754. if(ucDigDot4==1)
  755. {
  756. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  757. }
  758. dig_hc595_drive(ucDigShowTemp,0xf7);
  759. break;
  760. case 5://显现第5位
  761. ucDigShowTemp=dig_table[ucDigShow5];
  762. if(ucDigDot5==1)
  763. {
  764. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  765. }
  766. dig_hc595_drive(ucDigShowTemp,0xef);
  767. break;
  768. case 6://显现第6位
  769. ucDigShowTemp=dig_table[ucDigShow6];
  770. if(ucDigDot6==1)
  771. {
  772. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  773. }
  774. dig_hc595_drive(ucDigShowTemp,0xdf);
  775. break;
  776. case 7://显现第7位
  777. ucDigShowTemp=dig_table[ucDigShow7];
  778. if(ucDigDot7==1)
  779. {
  780. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  781. }
  782. dig_hc595_drive(ucDigShowTemp,0xbf);
  783. break;
  784. case 8://显现第8位
  785. ucDigShowTemp=dig_table[ucDigShow8];
  786. if(ucDigDot8==1)
  787. {
  788. ucDigShowTemp=ucDigShowTemp|0x80;//显现小数点
  789. }
  790. dig_hc595_drive(ucDigShowTemp,0x7f);
  791. break;
  792. }
  793. ucDisplayDriveStep++;
  794. if(ucDisplayDriveStep>8)//扫描完8个数码管后，从头从榜首个开端扫描
  795. {
  796. ucDisplayDriveStep=1;
  797. }
  799. }
  801. //数码管的74HC595驱动函数
  802. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
  803. {
  804. unsigned char i;
  805. unsigned char ucTempData;
  806. dig_hc595_sh_dr=0;
  807. dig_hc595_st_dr=0;
  808. ucTempData=ucDigStatusTemp16_09;//先送高8位
  809. for(i=0;i<8;i++)
  810. {
  811. if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  812. else dig_hc595_ds_dr=0;
  813. dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  814. delay_short(1);
  815. dig_hc595_sh_dr=1;
  816. delay_short(1);
  817. ucTempData=ucTempData<<1;
  818. }
  819. ucTempData=ucDigStatusTemp08_01;//再先送低8位
  820. for(i=0;i<8;i++)
  821. {
  822. if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  823. else dig_hc595_ds_dr=0;
  824. dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  825. delay_short(1);
  826. dig_hc595_sh_dr=1;
  827. delay_short(1);
  828. ucTempData=ucTempData<<1;
  829. }
  830. dig_hc595_st_dr=0;//ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上而且锁存起来
  831. delay_short(1);
  832. dig_hc595_st_dr=1;
  833. delay_short(1);
  834. dig_hc595_sh_dr=0; //拉低，抗干扰就增强
  835. dig_hc595_st_dr=0;
  836. dig_hc595_ds_dr=0;
  837. }
  839. //LED灯的74HC595驱动函数
  840. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
  841. {
  842. unsigned char i;
  843. unsigned char ucTempData;
  844. hc595_sh_dr=0;
  845. hc595_st_dr=0;
  846. ucTempData=ucLedStatusTemp16_09;//先送高8位
  847. for(i=0;i<8;i++)
  848. {
  849. if(ucTempData>=0x80)hc595_ds_dr=1;
  850. else hc595_ds_dr=0;
  851. hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  852. delay_short(1);
  853. hc595_sh_dr=1;
  854. delay_short(1);
  855. ucTempData=ucTempData<<1;
  856. }
  857. ucTempData=ucLedStatusTemp08_01;//再先送低8位
  858. for(i=0;i<8;i++)
  859. {
  860. if(ucTempData>=0x80)hc595_ds_dr=1;
  861. else hc595_ds_dr=0;
  862. hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  863. delay_short(1);
  864. hc595_sh_dr=1;
  865. delay_short(1);
  866. ucTempData=ucTempData<<1;
  867. }
  868. hc595_st_dr=0;//ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上而且锁存起来
  869. delay_short(1);
  870. hc595_st_dr=1;
  871. delay_short(1);
  872. hc595_sh_dr=0; //拉低，抗干扰就增强
  873. hc595_st_dr=0;
  874. hc595_ds_dr=0;
  875. }
  878. void usart_receive(void) interrupt 4 //串口接纳数据中止
  879. {
  881. if(RI==1)
  882. {
  883. RI = 0;
  885. ++uiRcregTotal;
  886. if(uiRcregTotal>const_rc_size)//超越缓冲区
  887. {
  888. uiRcregTotal=const_rc_size;
  889. }
  890. ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接纳到的数据缓存到接纳缓冲区里
  892. if(ucSendCntLock==0)//原子锁判别
  893. {
  894. ucSendCntLock=1; //加锁
  895. uiSendCnt=0;//及时喂狗，虽然在守时中止那儿此变量会不断累加，可是只需串口的数据还没发送结束，那么它永久也长不大,由于每个串口接纳中止它都被清零。
  896. ucSendCntLock=0; //解锁
  897. }
  899. }
  900. else//我在其它单片机上都不必else这段代码的，可能在51单片机上多添加” TI = 0;”稳定性会更好吧。
  901. {
  902. TI = 0;//假如不是串口接纳中止，那么必定是串口发送中止，及时铲除发送中止的标志，不然一向发送中止
  903. }
  905. }
  907. void T0_time(void) interrupt 1 //守时中止
  908. {
  909. TF0=0;//铲除中止标志
  910. TR0=0; //关中止
  913. /* 注释一：
  914. * 此处多添加一个原子锁，作为中止与主函数同享数据的维护，实践上是学习了”红金龙吸味”关于原子锁的主张.
  915. */
  916. if(ucSendCntLock==0)//原子锁判别
  917. {
  918. ucSendCntLock=1; //加锁
  919. if(uiSendCnt
  920. {
  921. uiSendCnt++; //表面上这个数据不断累加，可是在串口中止里，每接纳一个字节它都会被清零，除非这个中心没有串口数据过来
  922. ucSendLock=1; //开自锁标志
  923. }
  924. ucSendCntLock=0; //解锁
  925. }
  927. if(ucVoiceLock==0) //原子锁判别
  928. {
  929. if(uiVoiceCnt!=0)
  930. {
  932. uiVoiceCnt–; //每次进入守时中止都自减1，直到等于零中止。才中止鸣叫
  933. beep_dr=0;//蜂鸣器是PNP三极管操控，低电平就开端鸣叫。
  935. }
  936. else
  937. {
  939. ; //此处多加一个空指令，想保持跟if括号句子的数量对称，都是两条指令。不加也能够。
  940. beep_dr=1;//蜂鸣器是PNP三极管操控，高电平就中止鸣叫。
  942. }
  943. }
  945. if(ucStatus!=0) //处于非待机的状况,Led闪耀
  946. {
  947. uiLedCnt++; //Led闪耀计时器不断累加
  948. }
  950. if(ucStatus==1) //处于正在通讯的状况,
  951. {
  952. if(ucSendTimeOutLock==0)//原子锁判别
  953. {
  954. uiSendTimeOutCnt++; //超时计时器累加
  955. if(uiSendTimeOutCnt>const_send_time_out)//超时犯错
  956. {
  957. uiSendTimeOutCnt=0;
  958. ucStatus=2;//切换到犯错报警状况
  959. }
  960. }
  961. }
  965. key_scan(); //按键扫描函数
  966. display_drive();//数码管字模的驱动函数
  968. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  969. TL0=0x0b;
  970. TR0=1;//开中止
  971. }
  973. void delay_short(unsigned int uiDelayShort)
  974. {
  975. unsigned int i;
  976. for(i=0;i
  977. {
  978. ; //一个分号相当于履行一条空句子
  979. }
  980. }
  982. void delay_long(unsigned int uiDelayLong)
  983. {
  984. unsigned int i;
  985. unsigned int j;
  986. for(i=0;i
  987. {
  988. for(j=0;j<500;j++)//内嵌循环的空指令数量
  989. {
  990. ; //一个分号相当于履行一条空句子
  991. }
  992. }
  993. }
  995. void initial_myself(void)//榜首区 初始化单片机
  996. {
  997. /* 注释二：
  998. * 矩阵键盘也能够做独立按键，条件是把某一根公共输出线输出低电平，
  999. * 模仿独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
  1000. * 朱兆祺51学习板的S1便是本程序中用到的一个独立按键。
  1001. */
  1002. key_gnd_dr=0; //模仿独立按键的地GND，因而有必要一向输出低电平
  1003. led_dr=1;//点亮独立LED灯
  1004. beep_dr=1; //用PNP三极管操控蜂鸣器，输出高电平时不叫。
  1005. hc595_drive(0x00,0x00);//封闭一切通过别的两个74HC595驱动的LED灯
  1006. TMOD=0x01;//设置守时器0为工作方法1
  1007. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  1008. TL0=0x0b;
  1010. //装备串口
  1011. SCON=0x50;
  1012. TMOD=0X21;
  1014. /* 注释三：
  1015. * 为了确保串口中止接纳的数据不丢掉，有必要设置IP = 0x10，相当于把串口中止设置为最高优先级，
  1016. * 这个时分，串口中止能够打断任何其他的中止服务函数完结嵌套，
  1017. */
  1018. IP =0x10;//把串口中止设置为最高优先级，有必要的。
  1020. TH1=TL1=-(11059200L/12/32/9600);//串口波特率为9600。
  1021. TR1=1;
  1022. }
  1023. void initial_peripheral(void) //第二区 初始化外围
  1024. {
  1026. ucDigDot8=0; //小数点悉数不显现
  1027. ucDigDot7=0;
  1028. ucDigDot6=0;
  1029. ucDigDot5=0;
  1030. ucDigDot4=0;
  1031. ucDigDot3=0;
  1032. ucDigDot2=0;
  1033. ucDigDot1=0;
  1035. EA=1; //开总中止
  1036. ES=1; //答应串口中止
  1037. ET0=1; //答应守时中止
  1038. TR0=1; //发动守时中止
  1039. }

总结陈词：
这节具体讲了从机收发端的程序结构，而主机端的程序则用电脑的串口帮手来模仿。实践上，主机端的程序也有许多内容，它包含顺次发送每一串数据，依据回来的应对来决议是否需求重发数据，重发三次假如没反应则进行报错，以及超时没接纳到数据等等内容。主机收发端的程序结构是什么样的？欲知概况，请听下回分化—–主机的串口收发归纳程序结构

声明：本文内容来自网络转载或用户投稿，文章版权归原作者和原出处所有。文中观点，不代表本站立场。若有侵权请联系本站删除（kf@86ic.com）https://www.86ic.net/yingyong/iot/262080.html
2赞
标签:

为您推荐

多核架构高性能电机控制芯片

深度解析DCDC电路中的前馈电容应用

压电薄膜传感器与倾斜传感器提供灵敏的控制能力

如何为你的应用选择UWB的拓扑结构？

设计基于超级电容器的简单而紧凑的UPS

AMD FPGA的MicroBlaze固化过程详解

联系我们

联系我们

在线咨询: QQ交谈

邮箱: kf@86ic.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部