找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1282|回复: 2
打印 上一主题 下一主题
收起左侧

下面这个单片机程序里的二维数组问题

[复制链接]
跳转到指定楼层
楼主
ID:65237 发表于 2020-4-22 21:28 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
这是
zhangxinchun的贴子  有这段没看明白  da1527[rep][ii]&=~(1<<((7-k)));数组里的值是最后多少
                            特别是这里~(1<<((7-k))) 望高人们指点

单片机源程序如下:
  1. //测试单片机:STC15W408AS

  2. //晶振:内部 11.0592mHZ

  3. //复位方式:内部复位
  4.                      
  5. //串口通讯:波特率9600/数据位8/停止位1/无校验

  6. //调试环境:KEIL3

  7. //程序功能:实现2262解码,学习、自适应多阻值,片内EEPROM,存储60个遥控器数据
  8.         
  9. //          不依赖硬件,不占用硬件资源。移植更加方便

  10. //                        学习遥控器:按一下学习键,学习灯点亮,松开学习键,按动要学习的遥控器按键,学习灯熄灭,学习成功。重复上述操作可学习多个遥控器.
  11. //
  12. //          清除:按住学习键不放,直到学习灯自动熄灭,擦除成功.

  13. /**********************************************************/


  14. #include <STC15W408AS.h>
  15. #include <intrins.h>
  16. #define uchar unsigned char
  17. #define uint  unsigned int
  18. sbit RF                           =        P1^1;          //信号输入
  19. sbit LED                =        P3^3;          //学习指示灯
  20. sbit set                 =        P1^2;          //学习键                                                         
  21. sbit D0                        =        P3^4;          //1号继电器解码输出
  22. sbit D1                        =        P3^5;     //2号继电器
  23. sbit D2                        =        P3^6;          //3号继电器
  24. sbit D3                        =        P3^7;          //4号继电器
  25. sbit deng1      =        P1^7;          //K1指示灯
  26. sbit deng2      =        P5^4;          //K2指示灯
  27. sbit deng3      =        P5^5;          //K3指示灯
  28. sbit deng4      =        P3^2;          //K4指示灯
  29. sbit VT                        =        P1^0;     //接收指示灯                                
  30. sbit aj1                =   P1^3;          //K1
  31. sbit aj2                =   P1^4;          //K2
  32. sbit aj3                =   P1^5;          //K3
  33. sbit aj4                =   P1^6;          //K4
  34. bit  decode_ok;                 //解码成功
  35. bit rf_ok;               //收到有效数据
  36. bit study;         //学习标志
  37. bit jmnx;  //编码类型 0是2262,1是1527
  38. bit m=0,ba=0,ca=0,da=0,ea=0,za=0,aa=0,hv=0,ff=0,ra=0,rb=0,rc=0,rd=0,g=0,hm=0,biao=0,kt=0;
  39. bit biao_1=0,g_1=0,kt_1=0,hm_1=0;
  40. bit biao_2=0,g_2=0,kt_2=0,hm_2=0;
  41. bit biao_3=0,g_3=0,kt_3=0,hm_3=0;
  42. uchar da1527[2][3];  //解码过程中临时数组
  43. uchar key_d;  //遥控器按键码
  44. uchar short_k;     //窄脉冲宽度
  45. uchar ss=0,sn=0,h=0,yz=0,hh=0,yy=0,yk=0,yu=0;hk=0,sj=0,so=0,jk=0,hu=0,t1=0,t2=0,t3=0,t4=0;
  46. uint dt=0,dr=0,dq=0,rv=0,rv_1=0,rv_2=0,rv_3=0;
  47. uchar trg=0,trg_1=0,trg_2=0,trg_3=0,cont=0,cont_1=0,cont_2=0,cont_3=0;
  48. uchar ReadData=0,ReadData_1=0,ReadData_2=0,ReadData_3=0;
  49. static uint sk=0;
  50. uchar xdata key_number[181];                //遥控器编码数组,存放60个遥控器


  51. void delay_1ms(uint x)    //1毫秒延时
  52. {
  53.         uchar b,c;
  54.         for(x;x>0;x--)
  55.                 {
  56.                         for(b=3;b>0;b--)
  57.                                 {
  58.                                         for(c=150;c>0;c--);
  59.                                 }
  60.                 }
  61. }

  62. void delay(uint ms)//
  63. {
  64.   while(ms--)
  65.     {
  66.          ms++;

  67.          ms--;
  68.     }
  69. }




  70. //====================================================
  71. /////////片内EEPROM读写驱动程序///////////////////////////
  72. //====================================================


  73. void IAP_Disable()           //关闭IAP
  74. {
  75.     //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
  76.     //一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
  77.     IAP_CONTR = 0;      //关闭IAP 功能
  78.     IAP_CMD   = 0;      //清命令寄存器,使命令寄存器无命令,此句可不用
  79.     IAP_TRIG = 0;      //清命令触发寄存器,使命令触发寄存器无触发,此句可不用
  80.     IAP_ADDRH = 0;
  81.     IAP_ADDRL = 0;
  82. }//



  83. //读一字节,调用前需打开IAP 功能,入口:DPTR = 字节地址,返回:A = 读出字节
  84. uchar read_add(uint addr)         //读EEPROM
  85. {
  86.     IAP_DATA = 0x00;
  87.     IAP_CONTR = 0x84;         //打开IAP 功能, 设置Flash 操作等待时间
  88.     IAP_CMD = 0x01;                 //IAP/ISP/EEPROM 字节读命令

  89.     IAP_ADDRH = addr>>8;    //设置目标单元地址的高8 位地址
  90.     IAP_ADDRL = addr&0xff;    //设置目标单元地址的低8 位地址

  91.     EA = 0;
  92.     IAP_TRIG = 0x5a;   //先送 46h,再送B9h 到ISP/IAP 触发寄存器,每次都需如此
  93.     IAP_TRIG = 0xa5;   //送完 B9h 后,ISP/IAP 命令立即被触发起动
  94.     _nop_();
  95.     EA = 1;
  96.     IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
  97.                     //一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
  98.     return (IAP_DATA);
  99. }//------------------------------------------------------------------------------


  100. //字节编程,调用前需打开IAP 功能,入口:DPTR = 字节地址, A= 须编程字节的数据
  101. void write_add(uint addr,uchar ch)         //直接写EEPROM
  102. {
  103.     IAP_CONTR = 0x84;         //打开 IAP 功能, 设置Flash 操作等待时间
  104.     IAP_CMD = 0x02;                 //IAP/ISP/EEPROM 字节编程命令


  105.     IAP_ADDRH = addr>>8;    //设置目标单元地址的高8 位地址
  106.     IAP_ADDRL = addr&0xff;    //设置目标单元地址的低8 位地址

  107.     IAP_DATA = ch;                  //要编程的数据先送进IAP_DATA 寄存器
  108.     EA = 0;
  109.     IAP_TRIG = 0x5a;   //先送 46h,再送B9h 到ISP/IAP 触发寄存器,每次都需如此
  110.     IAP_TRIG = 0xa5;   //送完 B9h 后,ISP/IAP 命令立即被触发起动
  111.     _nop_();
  112.     EA = 1;
  113.     IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
  114.                     //一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
  115. }//------------------------------------------------------------------------------
  116. //擦除扇区, 入口:DPTR = 扇区地址


  117. void Sector_Erase(uint addr)         //扇区擦除
  118. {
  119.      IAP_CONTR = 0x84;         //打开IAP 功能, 设置Flash 操作等待时间
  120.     IAP_CMD = 0x03;                 //IAP/ISP/EEPROM 扇区擦除命令

  121.     IAP_ADDRH =addr>>8;    //设置目标单元地址的高8 位地址
  122.     IAP_ADDRL =addr&0xff;    //设置目标单元地址的低8 位地址

  123.     EA = 0;
  124.     IAP_TRIG = 0x5a;   //先送 46h,再送B9h 到ISP/IAP 触发寄存器,每次都需如此
  125.     IAP_TRIG = 0xa5;   //送完 B9h 后,ISP/IAP 命令立即被触发起动
  126.     _nop_();
  127.     EA = 1;
  128. }//------------------------------------------------------------------------------



  129. //============================接收解码部分========================================//

  130. void RF_decode()         
  131. {
  132.            uchar ii=0,j=0,k=0,rep=0;
  133.             uint head_k=0;           //短脉冲宽度
  134.           uchar s;   
  135. //-------------------------------数据接收-----------------------------------------
  136.       short_k=0;
  137.           while(RF && j<250)         //检测头信号前一个高脉冲的宽度
  138.                    {
  139.                          delay(1);        
  140.                         short_k++;
  141.                  }
  142.           while(!RF)
  143.                    {
  144.                          delay(1);
  145.                         head_k++;
  146.                  } //检测头脉冲的宽度         
  147.       if(((short_k*24)<head_k) && (head_k<(short_k*38)))   //引导码宽度是窄脉冲的32倍 24/38
  148.          {                        
  149.             for(rep=0;rep<2;rep++)         
  150.                {  
  151.                              for(ii=0;ii<3;ii++)//3字节
  152.                              {
  153.                                    for(k=0;k<8;k++)//每个字节8位
  154.                                       {                                      
  155.                                                     j=0;
  156.                                                         while(RF && j<245)
  157.                                                                 {
  158.                                                                         delay(1);
  159.                                                                         j++;
  160.                                                                 }//
  161.                                                if(j>(short_k-short_k/2-short_k/3)&&j<(short_k*1.96))
  162.                                                                 {
  163.                                                                         da1527[rep][ii]&=~(1<<((7-k)));
  164.                                                                 }                                    
  165.                                                         else if(j>(short_k*1.96)&&j<(short_k*5))da1527[rep][ii]|=(1<<(7-k));                                                
  166.                                                 else {return;}          //乱码退出        
  167.                                                j=0;
  168.                                                         while(!RF && j<150){delay(2);j++;}      //跳过低电平                                   
  169.                                                  }
  170.                                  }//for(ii=0;ii<12;ii++)  
  171.                    j=0;while(RF && (j<200)){delay(1);j++;}            //跳个最后一个高脉冲                           
  172.                                head_k=0;while(!RF) {delay(1);head_k++;} //检测下一个前导信号的寬度  
  173.                                if((head_k<(short_k*26)) || (head_k>(short_k*38)))  {return;} //引导码宽度是窄脉冲的32倍  //乱码退出
  174.                            }
  175.             //+++++++++++++++++++++++++2262与1527数据分离处理++++++++++++++++++++++++++++++++++++++++              
  176.                          if((da1527[0][0]==da1527[1][0]) && (da1527[0][1]==da1527[1][1]) && (da1527[0][2]==da1527[1][2]))        //两次接收到的数据相同
  177.                       {         
  178.                      uchar u,i,x;
  179.                                          rf_ok=1;
  180.                                          for(i=0;i<3;i++)  //判定2262与1527
  181.                         {
  182.                            for(u=0;u<4;u++) {if(((da1527[0][i]>>(u*2)) & 3)==2) {i=80;break;}}  //有10则为1527
  183.                                                    if(i==80) break;
  184.                         }
  185.                      if(i==80)  //1527
  186.                         {
  187.                           key_d=da1527[1][2] & 0x0f;         //分出1527的按键值
  188.                           da1527[0][2]=da1527[1][2]>>4; //分出1527的后4位地址
  189.                                                   jmnx=1;         //为0是2262,1是1527
  190.                         }
  191.                        else      //2262
  192.                          {
  193.                           key_d=0;
  194.                           for(i=0;i<4;i++){if(((da1527[0][2]>>(i*2))&3)==3) key_d|=1<<i;}   //计算出2262的按键数据                                 
  195.                           da1527[0][2]=0x00; //2262无后4位地址,全为0
  196.                                                   jmnx=0;         //为0是2262,1是1527
  197.                                                   jk++;//自锁用,作用:按下按键不松手继电器状态不变,松开再按下改变,一次只改变一次状态,因为按下按键后遥控会一直发码,所以让jk一直自加,但是只取jk=1的值的状态
  198.                          }
  199.                                                    
  200.                                           if (!study)                //非学习状态
  201.                                                   {
  202.                                                         rf_ok=0;
  203.                                                         for(x=0;x<60;x++)
  204.                                                                    {
  205.                                                                         if((da1527[0][0]==key_number[x*3+1])&&(da1527[0][1]==key_number[x*3+2])
  206.                                                                                                                                         &&(da1527[0][2]==key_number[x*3+3]))//判断是否已学习过的编码
  207.                                                                                 {

  208. //                                                                                    D0=!(key_d&0x08);                //取得按键码
  209. //                                                                                        D1=!(key_d&0x04);
  210. //                                                                                        D2=!(key_d&0x02);
  211. //                                                                                        D3=!(key_d&0x01);
  212.                                             if(m==1)  //互锁
  213.                                                                                         {         
  214.                                                                                         if(key_d == 0x01){D0=0;D1=1;D2=1;D3=1;}//D4=1;D5=1;D6=1;D7=1;D8=1;D9=1;D10=1;D11=1;}//else{D0=1;}
  215.                                                                                         if(key_d == 0x02){D0=1;D1=0;D2=1;D3=1;}//D4=1;D5=1;D6=1;D7=1;D8=1;D9=1;D10=1;D11=1;}
  216. //                                                                                        if(key_d == 0x03){D0=1;D1=1;D2=0;D3=1;D4=1;D5=1;D6=1;D7=1;D8=1;D9=1;D10=1;D11=1;}
  217.                                                                                         if(key_d == 0x04){D0=1;D1=1;D2=0;D3=1;}//D4=1;D5=1;D6=1;D7=1;D8=1;D9=1;D10=1;D11=1;}
  218. //                                                                                        if(key_d == 0x05){D0=1;D1=1;D2=1;D3=1;D4=0;D5=1;D6=1;D7=1;D8=1;D9=1;D10=1;D11=1;}
  219. //                                                                                        if(key_d == 0x06){D0=1;D1=1;D2=1;D3=1;D4=1;D5=0;D6=1;D7=1;D8=1;D9=1;D10=1;D11=1;}
  220. //                                                                                        if(key_d == 0x07){D0=1;D1=1;D2=1;D3=1;D4=1;D5=1;D6=0;D7=1;D8=1;D9=1;D10=1;D11=1;}
  221.                                                                                         if(key_d == 0x08){D0=1;D1=1;D2=1;D3=0;}//D4=1;D5=1;D6=1;D7=0;D8=1;D9=1;D10=1;D11=1;}
  222. //                                                                                        if(key_d == 0x09){D0=1;D1=1;D2=1;D3=1;D4=1;D5=1;D6=1;D7=1;D8=0;D9=1;D10=1;D11=1;}
  223. //                                                                                        if(key_d == 0x0a){D0=1;D1=1;D2=1;D3=1;D4=1;D5=1;D6=1;D7=1;D8=1;D9=0;D10=1;D11=1;}
  224. //                                                                                        if(key_d == 0x0b){D0=1;D1=1;D2=1;D3=1;D4=1;D5=1;D6=1;D7=1;D8=1;D9=1;D10=0;D11=1;}
  225. //                                                                                        if(key_d == 0x0c){D0=1;D1=1;D2=1;D3=1;D4=1;D5=1;D6=1;D7=1;D8=1;D9=1;D10=1;D11=0;}
  226.                                                                                         }
  227.                                                                                         else
  228.                                                                                         {
  229.                                                                                         if(ba==0) //B按键自锁
  230.                                                                                         {
  231.                                                                                      if(key_d == 0x04)
  232.                                                                                           {
  233.                                                                                                   if(jk==1)
  234.                                                                                                    {
  235.                                                                                                      D2=~D2;
  236.                                                                                                         }
  237.                                                                                             }
  238.                                                                                          } //B自锁

  239.                                                                                          if(da==0) //A按键自锁
  240.                                                                                         {
  241.                                                                                      if(key_d == 0x08)
  242.                                                                                           {
  243.                                                                                                  if(jk==1)
  244.                                                                                                    {
  245.                                                                                                      D3=~D3;
  246.                                                                                                         }
  247.                                                                                             }
  248.                                                                                          } //A自锁
  249.                                                                                          if(ca==0) //C按键自锁
  250.                                                                                         {
  251.                                                                                      if(key_d == 0x02)
  252.                                                                                           {
  253.                                                                                                  if(jk==1)
  254.                                                                                                    {
  255.                                                                                                      D1=~D1;
  256.                                                                                                         }
  257.                                                                                             }
  258.                                                                                          } //C自锁
  259.                                                                                          if(ea==0) //D按键自锁
  260.                                                                                         {
  261.                                                                                      if(key_d == 0x01)
  262.                                                                                           {
  263.                                                                                                  if(jk==1)
  264.                                                                                                    {
  265.                                                                                                      D0=~D0;
  266.                                                                                                         }
  267.                                                                                             }
  268.                                                                                          } //D自锁
  269.                                                                                          if(ba==1)//B按键点动,ba为自锁转点动标志位
  270.                                                                                          {
  271.                                                                                           if(key_d == 0x04){D2=0;}
  272.                                                                                           }
  273.                                                                                          if(da==1)//A按键点动,da为自锁转点动标志位
  274.                                                                                          {
  275.                                                                                           if(key_d == 0x08){D3=0;}
  276.                                                                                           }
  277.                                                                                           if(ca==1)//C按键点动,da为自锁转点动标志位
  278.                                                                                          {
  279.                                                                                           if(key_d == 0x02){D1=0;}
  280.                                                                                           }
  281.                                                                                           if(ea==1)//D按键点动,da为自锁转点动标志位
  282.                                                                                          {
  283.                                                                                           if(key_d == 0x01){D0=0;}
  284.                                                                                           }
  285.                                                                                         }                                                                                
  286.                                                                                         decode_ok=1;
  287.                                                                                         ss=1;
  288.                                                                                         sn=1;
  289.                                                                                         sj=1;
  290.                                                                                         so=1;
  291.                                                                                         VT=0;                                                               
  292.                                                                                         s=30;
  293.                                                                                         break;
  294.                                                                                 }
  295.                                                                                                                
  296.                                                                 }        
  297.                                                 
  298.                                                 
  299.                                                 }

  300.                  }
  301.               
  302.          }
复制代码

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

使用道具 举报

沙发
ID:191511 发表于 2020-4-23 10:23 | 只看该作者
~这个操作符是按位取反。
1<<x的意思是1向左移动x位,起始位是0位,1左移位结果二进制的话就是 0000 0100(一个字节的话)。
上边组合起来就是1左移x位之后,按位取反。那么上边的结果就会变成1111 1011。
之所以这么做,这是与矩阵按键判断所在行/列的值相关的
回复

使用道具 举报

板凳
ID:65237 发表于 2020-4-24 20:55 来自手机 | 只看该作者
wo4fisher 发表于 2020-4-23 10:23
~这个操作符是按位取反。
1

谢谢指点 这点我懂了 我还想请教数组是二维, 我想知程序进来这二个括号,等号右边值是给左边这二个括右边那个,还是左边括号,
如接收值是01010100 10011111 11110001那么这个二维数组是这样的吗[00000000][01010100] [11111111][10011111]   [22222222][11110001]请指点
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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