51单片机

请大神帮我看下我的程序错在哪里，串口通信给个指令测试RAM

2019-07-15 09:37发布

站内问答 / 51单片机
13486 0 981
本帖最后由 昨日的惆怅 于 2017-9-21 09:54 编辑
  1. #include <STC89C5xRC.H>
  2. #include<intrins.h>                 //头文件 调用_Nop_()函数
  3. #include <absacc.h>          //访问绝对地址的头文件
  4. #define uchar unsigned char        // unsigned char 宏定义为 uchar  unsigned char 就是0~255
  5. #define uint  unsigned int        // 定义uint为无符号整型。无符号整型就是说内存中表示这个数的二进制串没有符号位，也就是没有负数。
  6. #define _Nop_() _nop_()     //定义空指令
  7. #define ushort unsigned short



  11. bit  RAMERR;
  12. uchar RAMDATA,dat2,dat3;
  13. uint RAMADDR,RAMdat2;
  14. uchar flag, OK,ZZZ,NO,i,Dat;

  16. void InitUART(void)
  17. {
  18.     TMOD = 0x20;                                         //将timer1设置为Mode2以产生波特率
  19.     SCON = 0xd0;                                    //串口工作方式3,串口工作方式2有固定的波特率
  20.     TH1 = 0xfd;                                                //波特率9600
  21.     TL1 = TH1;
  22.     PCON = 0x00;                                        //将SMOD设置为0
  23.     TR1 = 1;                                                //开启定时器1
  24.         EA=1;                                                    //开启总中断
  25.         ES=1;                                                   //开启串口中断
  26. }
  27. void SendData(uchar Dat)                         //发送数据
  28. {
  29.     ACC = Dat;
  30.         CY=P;
  31.         TB8=~CY        ;
  32.         SBUF=ACC;
  33.     while(!TI);
  34.     TI = 0;                                 //软件复位         
  35. }

  37. void my_int1(void) interrupt 4                                 //串口中断服务程序
  38. {
  39.   RI=0;
  40.   ZZZ=SBUF;
  41.                                     //将SBUF中的数据读走给c, 这是此中断服务程序最重要的目的
  42.   flag = 1;                                                   //将标志位flag置1, 以方便在主程序中查询判断是否已经收到数据
  43. }


  46. void sendstring(uchar *p)   //送字符串
  47. {
  48.    
  49.   while(*p)
  50.   {
  51.   SendData(*p);
  52.   p++;
  53.   }
  54. }


  57. void delay1ms(int x) //1ms延时
  58. {        int i,j;                                        //声明整型变量i;j
  59.         for(i=0;i<x;i++)                        //计数x次，延迟xX1ms
  60.          for(j=0;j<120;j++);                //计数120次，延迟1ms
  61. }                                                                //延时函数结束
  62. void RAMwrite(uchar dat)
  63. {
  64.         for(RAMADDR=0x0000;RAMADDR<0x8000;RAMADDR++)          //15根地址线(0000 0000 0000 0000~1000 0000 0000 0000)
  65.         {
  66.                 XBYTE[RAMADDR]=dat;          //此地址对应一个字节,把数据（dat）写入地址（RAMADDR）即把数据写入62256如
  67.                                            //        XBYTE [0x4000] = 57;这赋值语句，就可以把57写到外部RAM的0x4000处了，此地址对应一个字节。

  69.                 _nop_();
  70.                 _nop_();
  71.                 _nop_();
  72.         }
  73. }
  74. void RAMread(uchar dat)
  75. {                                                                          


  78.         for(RAMADDR=0x0000;RAMADDR<0x8000;RAMADDR++)  //62256末地址        0X8000
  79.         {
  80.                 RAMDATA = XBYTE[RAMADDR];          //从62256读出数据

  82.                 _nop_();
  83.                 _nop_();
  84.                 _nop_();
  85.         if(RAMDATA==dat)        //比较数据
  86.                 {

  88.                   sendstring("RAMdat is OK.");

  90.                 }
  91.                 else
  92.                 {
  93.                         SendData(RAMADDR);
  94.                 }
  95.                 _nop_();
  96.                 _nop_();
  97.                
  98.         
  99.         }  
  100. }
  101. void RAMaddr_bus_check(void)
  102. {
  103.         uchar k;
  104.         uchar datt1;
  105.         uchar datt2;
  106. //        uchar ZZZ;
  107.     uint RAMaddr=1;
  108.    

  110.         XBYTE[0x0000]=0xff;                                                  //写数据 CCC==0XFF
  111.         delay1ms(1);
  112.         for(k=0;k<15;k++)
  113.         {               
  114.                 XBYTE[RAMaddr<<k]=k;
  115.                 delay1ms(1);
  116.                 datt1=XBYTE[RAMaddr<<k];                //datt1==k
  117.                 datt2=XBYTE[0x0000];                        //datt2==0xff
  118.                 if(datt1==k&&datt1!=datt2)                //datt1==k是测试ram地址总线是否读写数据一致，是否粘连 （一致，没有粘连，datt1等于K）
  119. //        for(k=1;k<16;k++)                                        //datt1!=datt2是测试ram地址总线是否断路  (datt1等于datt2,断路)   
  120. //         {
  121. //            XBYTE[RAMaddr<<k]=k;                                   //0x0001左移K
  122. //                delay1ms(1);
  123. //            datt1=XBYTE[RAMaddr<<k];
  124. //                datt2=XBYTE[RAMaddr<<(k-1)];
  125. //                if(datt1!=datt2)
  126.                 {                          
  127.                     RAMERR=0;                 
  128.                                  
  129.            }
  130.            else
  131.             {
  132.                   RAMERR=1;

  134.                 }
  135.            if(RAMERR==0)
  136.             {
  137.                     sendstring("RAMaddr bus is OK.");
  138.             _nop_();
  139.                  }         
  140.                if(RAMERR==1)
  141.                   {
  142.                    sendstring("RAMaddr bus is no.");
  143. //                   SendData(RAMaddr);
  144.                     }
  145.    }
  146. }
  147. void RAMdata_bus_check(void)
  148. {
  149.         uchar datt1,datt2,A;
  150.         for(A=0;A<8;A++)
  151.         {
  152.                 XBYTE[0x0000] = 0x00  ;                                   //写数据         ZZZ==0X00
  153.                 delay1ms(1 ) ;
  154.                 datt1 = XBYTE[0x0000]  ;
  155.                 delay1ms(1 ) ;
  156.                 if((datt1 & (0x01<<A)) == 0x00)
  157.                 {        
  158.                         XBYTE[0x0000] = (0x01<<A) ;
  159.                         delay1ms(1 ) ;
  160.                         datt2 = XBYTE[0x0000]  ;
  161.                         delay1ms(1 ) ;
  162.                         if(datt2 & (0x01<<A))               
  163.                         {
  164.                            RAMERR=0;

  166.                         }
  167.                         else
  168.                          {
  169.                             RAMERR=1;
  170.                           }
  171.                 }                           
  172.         }
  173.                 if(RAMERR==0)
  174.            {

  176.                   sendstring("RAMdata bus is OK.");

  178.          delay1ms(200);                 //LED2,LED3,LED4,LED5,LED6, 全亮 ，延迟5s
  179.         }
  180.                  if(RAMERR==1)
  181.                  {
  182.                    SendData(A);
  183.                    delay1ms(200);                         //LED2,LED3,LED4,LED5,LED6, 全灭 ，延迟5s
  184.                   }
  185.           }        
  186.         



  190. void main(void)                                                   //主程序
  191. {
  192.     InitUART();                                           //端口初始化
  193.         AUXR = 0x02;
  194.         while(1)
  195.    {

  197.      if(flag==1)                                   //若检测到flag为1, 说明程序已经执行过串口中断服务程序, 即收到了数据.
  198.         {

  200.                  flag=0;                                           //如果写入成功，标志位flag就变为0
  201.          ES=0;
  202.   
  203. //                 SendData(ZZZ);

  205.                  delay1ms(500);
  206.                  
  207.                 if(ZZZ==0xaa)
  208.                 {

  210.           RAMwrite(0xaa);        
  211.               delay1ms(500);
  212.           RAMread(0xaa);

  214.                   }
  215.                   if(ZZZ==0xff)
  216.                   {
  217.                   
  218.                     RAMaddr_bus_check();                //RAM地址总线检测是否有断线、粘线。
  219.                         delay1ms(500);

  221.                    }
  222.                    if(ZZZ==0x00)
  223.                    {

  225.                      RAMdata_bus_check();        //RAM数据总线检测是否有断路、粘线。
  226.                          delay1ms(500);

  228.                         }

  230. //                  if(RAMDATA==CCC)        //比较数据
  231. //                {
  232. //
  233. //                  sendstring("RAMaddress is OK.");
  234. //
  235. //                }
  236. //                else
  237. //                {
  238. //                        SendData(RAMADDR);
  239. //                }
  240. //                _nop_();
  241. //                _nop_();
  242. //
  243. //              delay1ms(1000);
  244.             }        
  245.        ES=1;                               //重新开启串口中断  
  246.                  
  247.          }                                                               

  249.         }

  251.    
  252.    




复制代码

发送
 看不清?
0条回答

一周热门 更多>