一个中断处理的问题,求助!

2019-07-15 19:09发布

  1. void main(void)
  2. {

  3.     nRF905Init();
  4.     Config905();
  5.     InitUART();

  6.     while(1)
  7.    {
  8.                 if(tmp=='*')
  9.                 {
  10.                         BELL = 0;   //蜂鸣器,调试用
  11.                         delay(50);
  12.                         BELL = 1;       
  13.                        
  14.                         for(i=0;i<10;i++)
  15.                         {
  16.                                 TxRxBuf[i] = JD[i];  //把数据送给发送缓冲
  17.                         }

  18.                         TX(); //发送数据
  19.                 }
  20.     }
  21. }
复制代码简单来说,是A机的串口接收到GPS数据后,发送给B机。
上面这种情况,能收到数据,蜂鸣器响。
可是,当我把发送数据的程序放到串口中断时(如下所示),就只有蜂鸣器响,而B机没有收到数据。
  1. //串口中断程序
  2. void ser_int (void) interrupt 4 using 1
  3. {

  4.         //以上为省略
  5.        
  6.         if(tmp=='*')
  7.         {
  8.                 BELL = 0;   //蜂鸣器,调试用
  9.                 delay(50);
  10.                 BELL = 1;       
  11.                
  12.                 for(i=0;i<10;i++)
  13.                 {
  14.                         TxRxBuf[i] = JD[i];  //把数据送给发送缓冲
  15.                 }

  16.                 TX(); //发送数据
  17.         }

  18. }
复制代码
这个时候,蜂鸣器响了,可是为什么B机却没有收到数据呢?求助大神!
友情提示: 此问题已得到解决,问题已经关闭,关闭后问题禁止继续编辑,回答。
11条回答
legend9082
2019-07-16 05:20
阿信509 发表于 2014-7-16 14:03
表面上看没啥问题
还是贴出来整个程序看看吧
  1. #include <reg52.h>
  2. #include <ABSACC.h>
  3. #include <intrins.h>
  4. #include <stdio.h>
  5. #define uint unsigned int
  6. #define uchar unsigned char
  7. //------------------------------------------------------位表示-----------------------------------------------
  8. #define BYTE_BIT0        0x01
  9. #define BYTE_BIT1        0x02
  10. #define BYTE_BIT2        0x04
  11. #define BYTE_BIT3        0x08
  12. #define BYTE_BIT4        0x10
  13. #define BYTE_BIT5        0x20
  14. #define BYTE_BIT6        0x40
  15. #define BYTE_BIT7        0x80
  16. //--------------------------------------------------------------------------------------------------------------
  17. sbit        KEY0 = P3^6;
  18. sbit        KEY1 = P3^7;
  19. sbit         BELL = P3^4;
  20. //----------------------------------------------------------------------------------------------------------------
  21. bdata unsigned   DATA_BUF;
  22. #define DATA7        ((DATA_BUF&BYTE_BIT7) != 0)
  23. #define DATA0   ((DATA_BUF&BYTE_BIT0) != 0)
  24. sbit        flag        =DATA_BUF^7;
  25. sbit        flag1        =DATA_BUF^0;
  26. //-------------------------------------------------发送数据缓冲区-------------------------------------------------------
  27. #define TxRxBuf_Len 32
  28. unsigned char TxRxBuf[TxRxBuf_Len];
  29. //------------------------------------------------NRF905配置口定义------------------------------------------------
  30. sbit        TXEN=P1^0;
  31. sbit        TRX_CE=P3^2;
  32. sbit        PWR=P1^1;
  33. //----------------------------------------------------------------------------------------------------------------
  34. sbit        MISO=P1^6;
  35. sbit        MOSI=P1^5;
  36. sbit        SCK=P1^7;
  37. sbit        CSN=P1^3;
  38. //----------------------------------------------------------------------------------------------------------------
  39. sbit        AM=P1^4;
  40. sbit        DR=P3^3;
  41. sbit        CD=P1^2;
  42. //--------------------------------------------------NRF905的SPI控制指令-------------------------------------------
  43. #define WC                0x00
  44. #define RC                0x10
  45. #define WTP                0x20
  46. #define RTP                0x21
  47. #define WTA                0x22
  48. #define RTA                0x23
  49. #define RRP                0x24

  50. //-----------------------------------------------------------------

  51. unsigned char  flag_rec =0;
  52. unsigned char  num_rec  =0;
  53.    
  54. unsigned char code kaijihuamian[]="HLJU-505";
  55. unsigned char code receiving[]="Receiving!";
  56. unsigned char code nodata[]="No GPS data!";

  57. char code TIME_AREA= 8;                //时区
  58. unsigned char flag_data;        //数据标志位

  59. //GPS数据存储数组
  60. unsigned char JD[10];                //经度
  61. unsigned char JD_a;                    //经度方向
  62. unsigned char WD[9];                //纬度
  63. unsigned char WD_a;                    //纬度方向
  64. unsigned char date[6];                //日期
  65. unsigned char time[6];                //时间
  66. unsigned char time1[6];                //时间
  67. unsigned char speed[5]={'0','0','0','0','0'};                //速度
  68. unsigned char high[6];                //高度
  69. unsigned char angle[5];                //方位角
  70. unsigned char use_sat[2];        //使用的卫星数
  71. unsigned char total_sat[2];        //天空中总卫星数
  72. unsigned char lock;                        //定位状态

  73. //串口中断需要的变量
  74. unsigned char seg_count;        //逗号计数器
  75. unsigned char dot_count;        //小数点计数器
  76. unsigned char byte_count;        //位数计数器
  77. unsigned char cmd_number;        //命令类型
  78. unsigned char mode;                        //0:结束模式,1:命令模式,2:数据模式
  79. unsigned char buf_full;                //1:整句接收完成,相应数据有效。0:缓存数据无效。
  80. unsigned char cmd[5];                //命令类型存储数组

  81. //-----------------------------------------------------------------------------------------------
  82. //-----------------------------------------------NRF905寄存器配置------------------------------------------------
  83. unsigned char idata RFConf[11]=
  84. {
  85.   0x00,                             //配置命令//
  86.   0x4c,                             //CH_NO,配置频段在430MHZ
  87.   0x0C,                             //输出功率为10dbm,不重发,节电为正常模式
  88.   0x44,                             //地址宽度设置,为4字节
  89.   0x20,0x20,                        //接收发送有效数据长度为4字节
  90.   0xCC,0xCC,0xCC,0xCC,              //接收地址
  91.   0x58,                              //CRC充许,8位CRC校验,外部时钟信号不使能,16M晶振
  92. };
  93. code TxAddress[4]={0xcc,0xcc,0xcc,0xcc};
  94. //-----------------------------------------------延时--------------------------------------------------------------
  95. static void delay(uchar n)
  96. {
  97.         uint i;
  98.         while(n--)
  99.         for(i=0;i<80;i++);
  100. }
  101. //----------------------------------------------SPI写函数---------------------------------------------------------
  102. void SpiWrite(unsigned char send)
  103. {
  104.         unsigned char i;
  105.         DATA_BUF=send;
  106.         for (i=0;i<8;i++)
  107.         {
  108.                 if (DATA7)        //总是发送最高位
  109.                 {
  110.                         MOSI=1;
  111.                 }
  112.                 else
  113.                 {
  114.                         MOSI=0;
  115.                 }
  116.                 SCK=1;
  117.                 DATA_BUF=DATA_BUF<<1;
  118.                 SCK=0;
  119.         }
  120. }
  121. //---------------------------------------------初始化nRF905状态-----------------------------------------------------
  122. void nRF905Init(void)
  123. {
  124.     CSN=1;                                                // Spi         disable
  125.         SCK=0;                                                // Spi clock line init low
  126.         DR=0;                                                // Init DR for input
  127.         AM=0;                                                // Init AM for input
  128.         CD=0;                                                // Init CD for input
  129.         PWR=1;                                        // nRF905 power on
  130.         TRX_CE=0;                                        // Set nRF905 in standby mode
  131.         TXEN=0;                                        // set radio in Rx mode
  132. }
  133. //----------------------------------------------NRF905初始化寄存器------------------------------------------------
  134. void Config905(void)
  135. {
  136.         uchar i;
  137.         CSN=0;                                                // Spi enable for write a spi command
  138.         //SpiWrite(WC);                                // Write config command写放配置命令
  139.         for (i=0;i<11;i++)        // Write configration words  写放配置字
  140.         {
  141.            SpiWrite(RFConf[i]);
  142.         }
  143.         CSN=1;                                        // Disable Spi
  144. }
  145. //----------------------------------------打包待发送的数据--------------------------------------------------------
  146. void TxPacket(void)
  147. {
  148.         uchar i;
  149.         //Config905();
  150.         CSN=0;
  151.         SpiWrite(WTP);                                // Write payload command
  152.         for (i=0;i<32;i++)
  153.         {
  154.                 SpiWrite(TxRxBuf[i]);                // Write 32 bytes Tx data
  155.         }// Spi enable for write a spi command
  156.         CSN=1;
  157.         delay(1);                                                // Spi disable
  158.         CSN=0;                                                // Spi enable for write a spi command
  159.         SpiWrite(WTA);                                // Write address command
  160.         for (i=0;i<4;i++)                        // Write 4 bytes address
  161.         {
  162.                 SpiWrite(TxAddress[i]);
  163.         }
  164.         CSN=1;                                                // Spi disable
  165.         TRX_CE=1;                                        // Set TRX_CE high,start Tx data transmission
  166.         delay(1);                                        // while (DR!=1);
  167.         TRX_CE=0;                                        // Set TRX_CE low
  168. }
  169. //--------------------------------------------设置发送模式----------------------------------------------------------
  170. void SetTxMode(void)
  171. {
  172.         TRX_CE=0;
  173.         TXEN=1;
  174.         delay(1);                                         // delay1 for mode change(>=650us)
  175. }
  176. //---------------------------------------------------------------------------------------------------------------
  177. unsigned char CheckCD(void)                //Pin->检查是否已存在 同频率载波
  178. {
  179.         if (CD==1)
  180.         {
  181.                 return 1;
  182.         }
  183.         else
  184.         {
  185.                 return 0;
  186.         }
  187. }
  188. //---------------------------------------------------数据发送--------------------------------------------------------------
  189. void TX(void)
  190. {
  191.            SetTxMode();// Set nRF905 in Tx mode
  192.         TxPacket();// Send data by nRF905
  193.         CheckCD();        // 返回CD的当前电平
  194. }







  195. void InitUART(void)        //9600  11.05926MHz
  196. {

  197.         SCON = 0x50;      //REN=1允许串行接受状态,串口工作模式1                             
  198.         TMOD|= 0x20;      //定时器工作方式2                    
  199.         PCON|= 0x80;                                                         
  200.         TH1 = 0xFa;                  //baud*2  /* reload value 9600、数据位8、停止位1。效验位无 (11.0592)                        
  201.     TL1 = 0xF3;         
  202.         TR1  = 1;                                                            
  203.         ES   = 1;         //开串口中断                  
  204.         EA   = 1;         // 开总中断
  205. }

  206. /**************************************
  207. //将UTC时间转成BJ时间
  208. void trans_time(void)
  209. {
  210.         unsigned char temp,hour_shi,hour_ge;
  211.         temp=(time[0]-'0')*10+(time[1]-'0');
  212.         if(temp<=16)
  213.         {
  214.                 temp=temp+8;
  215.                 hour_shi=temp/10;
  216.                 hour_ge=temp%10;
  217.                 time[0]=hour_shi+'0';
  218.                 time[1]=hour_ge+'0';
  219.        
  220.         }
  221.         else
  222.         {
  223.                 temp=temp+8-24;
  224.                 time[0]='0';
  225.                 time[1]=temp%10+'0';
  226.        
  227.         }

  228. }
  229. ***********************************/

  230. /**********************************
  231. //判断是否有GPS数据 有1,无0
  232. bit gps_data(void)
  233. {
  234.         if(buf_full&0x01!=0)
  235.                 return 1;
  236.         else
  237.                 return 0;       

  238. }
  239. **********************************/
  240. //--------------------------------------------------------------------
  241. //串口中断程序
  242. void ser_int (void) interrupt 4 using 1
  243. {
  244.        
  245.         unsigned char tmp;


  246.         if(RI)
  247.         {
  248.                 RI=0;
  249.                 tmp=SBUF;
  250.                 switch(tmp)
  251.                 {
  252.                         case '程序有点长了,这是能够接收到数据的程序
  253. :
  254.                                 cmd_number=0;                //命令类型清空
  255.                                 mode=1;                                //接收命令模式
  256.                                 byte_count=0;                //接收位数清空
  257.                                 flag_data=1;
  258.                                 flag_rec=1;                     //数据标志位置一
  259.                                 break;
  260.                         case ',':
  261.                                 seg_count++;                //逗号计数加1
  262.                                 byte_count=0;
  263.                                 break;
  264.                         case '*':
  265.                                 switch(cmd_number)
  266.                                 {
  267.                                         case 1:
  268.                                                 buf_full|=0x01;
  269.                                                 break;
  270.                                         case 2:
  271.                                                 buf_full|=0x02;
  272.                                                 break;
  273.                                         case 3:
  274.                                                 buf_full|=0x04;
  275.                                                 break;
  276.                                 }
  277.                                 mode=0;
  278.                                 break;
  279.                         default:
  280.                                 if(mode==1)        //命令种类判断
  281.                                 {
  282.                                         cmd[byte_count]=tmp;                        //接收字符放入类型缓存
  283.                                         if(byte_count>=4)
  284.                                         {                                //如果类型数据接收完毕,判断类型
  285.                                                 if(cmd[0]=='G')
  286.                                                 {
  287.                                                         if(cmd[1]=='N')
  288.                                                         {
  289.                                                                 if(cmd[2]=='G')
  290.                                                                 {
  291.                                                                         if(cmd[3]=='G')
  292.                                                                         {
  293.                                                                                 if(cmd[4]=='A')
  294.                                                                                 {
  295.                                                                                         cmd_number=1;      //data type
  296.                                                                                         mode=2;
  297.                                                                                         seg_count=0;
  298.                                                                                         byte_count=0;
  299.                                                                                 }
  300.                                                                         }
  301.                                                                         else if(cmd[3]=='S')
  302.                                                                         {
  303.                                                                                 if(cmd[4]=='V')
  304.                                                                                 {
  305.                                                                                         cmd_number=2;
  306.                                                                                         mode=2;
  307.                                                                                         seg_count=0;
  308.                                                                                         byte_count=0;
  309.                                                                                 }
  310.                                                                         }
  311.                                                                 }
  312.                                                                 else if(cmd[2]=='R')
  313.                                                                 {
  314.                                                                         if(cmd[3]=='M')
  315.                                                                         {
  316.                                                                                 if(cmd[4]=='C')
  317.                                                                                 {
  318.                                                                                         cmd_number=3;
  319.                                                                                         mode=2;
  320.                                                                                         seg_count=0;
  321.                                                                                         byte_count=0;
  322.                                                                                 }
  323.                                                                         }
  324.                                                                 }
  325.                                                         }
  326.                                                 }
  327.                                         }
  328.                                 }
  329.                                 else if(mode==2)
  330.                                 {
  331.                                         //接收数据处理
  332.                                         switch (cmd_number)
  333.                                         {
  334.                                                 case 1:                                //类型1数据接收。GPGGA
  335.                                                         switch(seg_count)
  336.                                                         {
  337.                                                                 case 2:                //纬度处理
  338.                                                                         if(byte_count<9)
  339.                                                                         {
  340.                                                                                 WD[byte_count]=tmp;
  341.                                                                         }
  342.                                                                         break;
  343.                                                                 case 3:                //纬度方向处理
  344.                                                                         if(byte_count<1)
  345.                                                                         {
  346.                                                                                 WD_a=tmp;
  347.                                                                         }
  348.                                                                         break;
  349.                                                                 case 4:                //经度处理
  350.                                                                         if(byte_count<10)
  351.                                                                         {
  352.                                                                                 JD[byte_count]=tmp;
  353.                                                                         }
  354.                                                                         break;
  355.                                                                 case 5:                //经度方向处理
  356.                                                                         if(byte_count<1)
  357.                                                                         {
  358.                                                                                 JD_a=tmp;
  359.                                                                         }
  360.                                                                         break;
  361.                                                                 case 6:                //定位判断
  362.                                                                         if(byte_count<1)
  363.                                                                         {
  364.                                                                                 lock=tmp;
  365.                                                                         }
  366.                                                                         break;
  367.                                                                 case 7:                //定位使用的卫星数
  368.                                                                         if(byte_count<2)
  369.                                                                         {
  370.                                                                                 use_sat[byte_count]=tmp;
  371.                                                                         }
  372.                                                                         break;
  373.                                                                 case 9:                //高度处理
  374.                                                                         if(byte_count<6)
  375.                                                                         {
  376.                                                                                 high[byte_count]=tmp;
  377.                                                                         }
  378.                                                                         break;
  379.                                                         }
  380.                                                         break;
  381.                                                 case 2:                                //类型2数据接收。GPGSV
  382.                                                         switch(seg_count)
  383.                                                         {
  384.                                                                 case 3:                //天空中的卫星总数
  385.                                                                         if(byte_count<2)
  386.                                                                         {
  387.                                                                                 total_sat[byte_count]=tmp;
  388.                                                                         }
  389.                                                                         break;
  390.                                                         }
  391.                                                         break;
  392.                                                 case 3:                                //类型3数据接收。GPRMC
  393.                                                         switch(seg_count)
  394.                                                         {
  395.                                                                 case 1:                //时间处理
  396.                                                                         if(byte_count<6)
  397.                                                                         {                               
  398.                                                                                 time[byte_count]=tmp;       
  399.                                                                         }
  400.                                                                         break;
  401.                                                                 case 2:                //定位判断                                               
  402.                                                                         if(byte_count<1)
  403.                                                                         {
  404.                                                                           if (tmp=='V') {lock=0;}
  405.                                                                           else
  406.                                                                           {
  407.                                                                             lock=1;
  408.                                                                            }
  409.                                                                         }
  410.                                                                         break;
  411.                                                                 case 3:                //纬度处理                                               
  412.                                                                         if(byte_count<9)
  413.                                                                         {
  414.                                                                                 WD[byte_count]=tmp;
  415.                                                                         }
  416.                                                                         break;
  417.                                                                 case 4:                //纬度方向处理                                               
  418.                                                                         if(byte_count<1)
  419.                                                                         {
  420.                                                                                 WD_a=tmp;
  421.                                                                         }
  422.                                                                         break;
  423.                                                                 case 5:                //经度处理                                               
  424.                                                                         if(byte_count<10)
  425.                                                                         {
  426.                                                                                 JD[byte_count]=tmp;
  427.                                                                         }
  428.                                                                         break;
  429.                                                                 case 6:                //经度方向处理                                               
  430.                                                                         if(byte_count<1)
  431.                                                                         {
  432.                                                                                 JD_a=tmp;
  433.                                                                         }
  434.                                                                         break;
  435.                                                                 case 7:                //速度处理                                               
  436.                                                                         if(byte_count<5)
  437.                                                                         {
  438.                                                                                 speed[byte_count]=tmp;
  439.                                                                         }
  440.                                                                         break;
  441.                                                                 case 8:                //方位角处理                                               
  442.                                                                         if(byte_count<5)
  443.                                                                         {
  444.                                                                                 angle[byte_count]=tmp;
  445.                                                                         }
  446.                                                                         break;
  447.                                                                 case 9:                //方位角处理                                               
  448.                                                                         if(byte_count<6)
  449.                                                                         {
  450.                                                                                 date[byte_count]=tmp;
  451.                                                                         }
  452.                                                                         break;

  453.                                                         }
  454.                                                         break;
  455.                                         }
  456.                                 }
  457.                                 byte_count++;                //接收数位加1
  458.                                 break;
  459.                 }
  460.         }




  461. }

  462. //------------------------------------主函数-------------------------------------
  463. void main(void)
  464. {
  465.         uchar i;
  466.     nRF905Init();
  467.     Config905();
  468.     InitUART();


  469.     while(1)
  470.         {
  471.                 if(JD[0]=='1')
  472.                 {
  473.                        
  474.                         for(i=0;i<10;i++)
  475.                         {
  476.                                 TxRxBuf[i] = JD[i];  //把数据送给发送缓冲
  477.                         }
  478.        
  479.                         TX(); //发送数据
  480.                 }
  481.         }
  482. }



复制代码程序有点长了,这是能够接收到数据的程序

一周热门 更多>