设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 为什么这个单片机串口程序只可以接收不可以发送呢?
返回列表 发新帖
查看: 1982|回复: 6
打印 上一主题 下一主题
收起左侧

为什么这个单片机串口程序只可以接收不可以发送呢?

[复制链接]
跳转到指定楼层
楼主
ID:974783 发表于 2021-10-25 14:05 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. #include<reg51.h>

  3. #define FOSC 11059200UL//晶振值
  4. //#define baud 9600
  5. #define BRT (65536 - FOSC / baud / 4)//重载值

  7. sfr AUXR = 0x8e;
  8. sfr T2H = 0xd6;
  9. sfr T2L = 0xd7;
  10. sfr P1M0=0x92;
  11. sfr P1M1=0x91;
  12. sfr P3M0 = 0xb2;
  13. sfr P3M1 = 0xb1;
  14. sbit rts=P3^3;
  15. sfr P_SW1 = 0xa2;
  16. sbit red=P1^7;
  17. //sbit green=P1^2;
  18. //sbit yellow=P3^2;
  19. //sbit travelswitch=P3^4;


  22. char buft[20]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10,0x11};//数据发送缓冲
  23. char bufr[20];//接收
  24. char buf[30];//保存数据
  25. int flagtxd=0;//发送标志
  26. int flag0_5s=0;//定时0.5秒的标志
  27. int cnt=0;//定时计数标志
  28. int flagred=0;//红灯闪烁标志
  29. int rlen=0;//接收数据的长度

  31. void ea_on();//开总中断
  32. void ea_off();//关总中断
  33. void configuart(int baud);//串口配置，baud为波特率
  34. void uartinit();//串口初始化配置
  35. void uart_interrupt_on();//串口中断打开
  36. void uart_interrupt_off();//串口中断关闭
  37. //void uart_r(char *bufr,char len);//串口接收
  38. void uart_t();//串口发送
  39. void max485(bit x);//max485x为0接收为1发送

  41. void timerpattern();//定时器模式
  42. void timerinitialize();//定时器初值
  43. void timert0on();//定时器T0启动
  44. void timert0off();//定时器T0关闭
  45. void t0interrupton();//开TO中断
  46. void t0interruptoff();//关T0中断
  47. void redledon();//红灯亮
  48. void redledoff();//红灯灭
  49. //void greenledon();//绿灯亮
  50. //void greenledoff();//绿灯灭
  51. //void yellowledon();//黄灯亮
  52. //void yellowledoff();//黄灯灭
  53. void redblink();//红灯闪
  54. void iopattern();//IO口配置

  56. char analysis_len(char *bufr,char rlen);//解析串口一段数据长度
  57. void analysis();//解析数据

  59. void main()
  60. {        
  61.         iopattern();
  62.         timerpattern();
  63.         timerinitialize();
  64.         ea_on();
  65.         t0interrupton();
  66.         //timert0on();
  67.         
  68.         red=0;
  69.         //max485(0);        //max485为接收
  70.         max485(1);
  71.          uartinit();
  72.         configuart(9600);
  73.         uart_interrupt_on();
  74. //        analysis_len(bufr,rlen);
  75.         
  76. //        analysis();
  77.         
  78.         
  79.         
  80.         
  81.         while(1)
  82.         {         
  83.                  //analysis();
  84.                  //uart_t();
  85.                  red=1;
  86.                  flagtxd=1;
  87.                  SBUF=buft[5];
  88.                  while(flagtxd);
  89. //                 switch(buf[0])
  90. //                 {
  91. //                         case 0x01:redledon();break;
  92. //                        case 0x02:redblink();break;
  93. //                        case 0x03:redledoff();break;
  94. //                 }
  95.                 //redblink();
  96.                
  97.         }
  98. }                                       
  99.                                           


  102. void ea_on()//开总中断
  103. {
  104.         EA=1;
  105. }

  107. void ea_off()//关总中断
  108. {
  109.         EA=0;
  110. }

  112. void configuart(int baud)//串口配置，baud为波特率
  113. {
  114.          
  115.         T2L =(65536 - FOSC / baud / 4);
  116.         T2H =(65536 - FOSC / baud / 4)>> 8;
  117.         AUXR = 0x15;//定时器2作波特率发生器

  119. }

  121. void uartinit()//串口初始化配置
  122. {
  123.         P_SW1 = 0x40; //RXD_2/P3.6, TXD_2/P3.7
  124.         SCON = 0x50;//设置串口为模式1可变波特率8位数据方式
  125. //        INT_CLKO &= ~0x02;        //不输出时钟

  127. }

  129. void uart_interrupt_on()//串口中断打开
  130. {
  131.         ES=1;
  132. }
  133.         
  134. void uart_interrupt_off()//串口中断关闭
  135. {
  136.         ES=0;
  137. }

  139. //void uart_r(char *bufr,char len)//接收
  140. //{
  141. //        int i;
  142. //        if((SBUF^0x02)!=0)//是否为0x02开头不是则丢弃数据
  143. //        {
  144. //                for(i=0;i<=len;i++)
  145. //                {
  146. //                        bufr[i]=SBUF;
  147. //                        while(!RI)
  148. //                        {
  149. //                                flag0_5s=0;
  150. //                                timert0on();
  151. //                                t0interrupton();
  152. //                                if(flag0_5s==1)
  153. //                                {
  154. //                                        flag0_5s=0;
  155. //                                        timert0off();
  156. //                                        t0interruptoff();
  157. //                                        break;
  158. //                                }
  159. //                                
  160. //                        }
  161. //                }
  162. //        }
  163. //}

  165. void uart_t()//发送
  166. {
  167.         int i;        
  168.                 for(i=0;i<10;i++)
  169.                 {
  170.                         flagtxd=0;
  171.                         SBUF=buft[i];
  172.                         while(!flagtxd);//等待发送结束
  173. //                        {
  174. //                                timert0on();
  175. //                                t0interrupton();
  176. //                                if(flag0_5s==1)
  177. //                                {
  178. //                                        flag0_5s=0;
  179. //                                        timert0off();
  180. //                                        t0interruptoff();
  181. //                                        break;
  182. //                                }
  183. //                                
  184. //                        }
  185.                 }
  186. }

  188. void max485(bit x)
  189. {
  190.         rts=x;
  191. }

  193. void timerpattern()
  194. {
  195.         TMOD=0x01;
  196. }//定时器为模式1非自动重载

  198. void timerinitialize()
  199. {
  200.         TH0=0xD5;
  201.         TL0=0x08;
  202. }//定时器初始化

  204. void timert0on()
  205. {
  206.         TR0=1;
  207. }//定时器T0启动

  209. void timert0off()
  210. {
  211.         TR0=0;
  212. }//定时器T0关闭

  214. void t0interrupton()
  215. {
  216.         ET0=1;
  217. }//开TO中断

  219. void t0interruptoff()
  220. {
  221.         ET0=0;
  222. }//关T0中断

  224. void redledon()
  225. {
  226.         red=1;
  227. }
  228. //红灯亮

  230. void redledoff()
  231. {
  232.         red=0;
  233. }
  234. //红灯灭

  236. //void greenledon()
  237. //{
  238. //        green=1;
  239. //}
  240. ////绿灯亮
  241. //
  242. //void greenledoff()
  243. //{
  244. //        green=0;
  245. //}//绿灯灭
  246. //
  247. //void yellowledon()
  248. //{
  249. //        yellow=1;
  250. //}//黄灯亮
  251. //
  252. //void yellowledoff()
  253. //{
  254. //        yellow=0;
  255. //}//黄灯灭

  257. void redblink()
  258. {
  259.         if(flagred==1)
  260.         {
  261.                 flagred=0;
  262.                 red=~red;
  263.         }
  264. }

  266. void iopattern()
  267. {
  268.         P1M0=0x00;//准双向模式
  269.         P1M1=0x00;
  270.         P3M0=0x88;
  271.         P3M1=0x00;
  272. }//IO口配置

  274. //char analysis_len(char *bufr,char len)
  275. //{
  276. //        char cnt,i,j;
  277. //        char k=0;
  278. //        for(i=0;i<=len;i++)
  279. //        {
  280. //                if(bufr[i]==0x02)
  281. //                {
  282. //                        cnt=1;
  283. //                        buf[k]=bufr[i];
  284. //                        for(j=0;j<=len;j++)
  285. //                        {
  286. //                                cnt++;
  287. //                                buf[k++]=bufr[i+j];
  288. //                                if(bufr[i+j]==0x03)
  289. //                                {
  290. //                                        return cnt;
  291. //                                }
  292. //                        }
  293. //                }
  294. //               
  295. //        }
  296. //        return 0;               
  297. //}

  299. void analysis()
  300. {
  301.         int i;
  302.         for(i=0;i<=30;i++)
  303.         {
  304.                 if(buf[i]==0x02)
  305.                         {
  306.                                 if(buf[i+1]==0x30)
  307.                                 {
  308.                                         if(buf[i+3]==0x30)
  309.                                         {
  310.                                                 if(buf[i+4]==0x30)
  311.                                                 {
  312.                                                         if(buf[i+5]==0x03)
  313.                                                         {
  314.                                                                 switch (buf[i+2])
  315.                                                                 {
  316.                                                                         case 0x31:redledon();break;
  317.                                                                         case 0x32:redblink();break;
  318.                                                                         case 0x33:redledoff();break;
  319.                                                                 }
  320.                                                         }
  321.                                                 }
  322.                                         }
  323.                                 }
  324.                         }
  325.         }




  330. //        if(buf[0]!=0x02)
  331. //                return;
  332. //        else if(buf[1]!=0x30)
  333. //                return;
  334. //        else if(buf[3]!=0x30)
  335. //                return;
  336. //        else if(buf[4]!=0x30)
  337. //                return;
  338. //        else if(buf[5]!=0x03)
  339. //                return;
  340. //        else
  341. //        //if(((buf[1]==0x30)&&(buf[3]==0x30))&&((buf[4]==0x30)&&(buf[5]==0x03)))
  342. //        {
  343. //                 switch(buf[2])
  344. //                {
  345. //                        case 0x31:redledon();break;
  346. //                        case 0x32:redblink();break;
  347. //                        case 0x33:redledoff();break;
  348. //                }
  349. //        }
  350. }                        



  354. void interrupttimer() interrupt 1
  355. {         
  356.                 TH0=0xD5;
  357.                 TL0=0x08;
  358.                 cnt++;
  359.         
  360.                 if(cnt>=50)
  361.                 {
  362.                         cnt=0;
  363.                         flag0_5s=1;
  364.                         flagred=1;
  365.                         //flag2s++;
  366.                         

  368.                 }
  369. }//中断定时0.5秒

  371. void uart_interrupt() interrupt 4//串口中断
  372. {
  373.         if(RI) //接收到字节
  374.         {
  375.                 RI=0;//软件清零接收中断标志位
  376.                 //if(rlen<20)
  377.                 //{
  378.                         buf[rlen]=SBUF;
  379.                         rlen++;
  380.                 //}
  381. //                if(rlen<20)
  382. //                {
  383. //                        bufr[rlen]=SBUF;
  384. //                        rlen++;
  385. //                }
  386.         }
  387.         if(TI)//发送字节
  388.         {
  389.                 TI=0;//软件清零发送中断标志位
  390.                 flagtxd=1;//发送完成标志
  391.                
  392.         }
  393. }
复制代码

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:624769 发表于 2021-10-25 15:34 | 只看该作者
从你的程序看……
        while(1)
        {         
                   flagtxd=1;
                 SBUF=buft[5];         <== 这里会发一次
                 while(flagtxd);         <===   一直停这里了。
          }
而，buft[5]; 是空值， 如果你串口助手是 16进制， 那么能收到一个 0x00，  是文本 的话什么也收不到。
回复

使用道具 举报

板凳
ID:974783 发表于 2021-10-25 16:20 | 只看该作者
188610329 发表于 2021-10-25 15:34
从你的程序看……
        while(1)
        {         

这样呢

void uart_t(char *buft,char len)//发送
{
        int i;       
                for(i=0;i<len;i++)
                {
                        flagtxd=0;
                        SBUF=*buft++;
                        if((SBUF^0x07)!=0)
                        {
                                red=1;
                        }
                        while(!flagtxd);//等待发送结束

这是中断

if(TI)//发送字节
        {
                TI=0;//软件清零发送中断标志位
                flagtxd=1;//发送完成标志
               
        }
回复

使用道具 举报

地板
ID:974783 发表于 2021-10-25 16:22 | 只看该作者
188610329 发表于 2021-10-25 15:34
从你的程序看……
        while(1)
        {         

找了一下午还是没明白为什么收不到
回复

使用道具 举报

5#
ID:624769 发表于 2021-10-25 17:34 | 只看该作者
大幅度释放的 发表于 2021-10-25 16:22
找了一下午还是没明白为什么收不到

如果，你只是要查串口发的问题，作一个简单试验不就好了？
主程序里
while(1)
{
      while(flagtxd);
      flagtxd = 1;
      SUBF  = 'A';
}

中断里
if(TI)//发送字节
        {
                TI=0;//软件清零发送中断标志位
                flagtxd=0;//发送完成标志
               
        }

如果成功工作，就会发很多  A 到你的 电脑。如果不成功就要查电路了。
回复

使用道具 举报

6#
ID:959346 发表于 2021-10-25 18:04 | 只看该作者
大幅度释放的 发表于 2021-10-25 16:20
这样呢

void uart_t(char *buft,char len)//发送

你主函数内没有用uart_t，直接
flagtxd=1;
                 SBUF=buft[5];
                 while(flagtxd);
了，有没有改一下？
回复

使用道具 举报

7#
ID:974783 发表于 2021-10-26 11:44 | 只看该作者
感谢各位！！！问题解决了是单片机有问题
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表