标题: 新手請教,電平輸入檢測?(以解決! 感谢wulin大神) [打印本页]
作者: karyboa    时间: 2017-8-23 11:50
标题: 新手請教,電平輸入檢測?(以解決! 感谢wulin大神)
請教各位大神,高手,前輩;
小弟剛學51單片機不久,現在要做一個電路,但遇到問題了,所以
來請教各位前輩,電路動作如下:

單片機:STC15W201S-DIP16
測試學習板:淘寶上購得某款的mini 89c52學習板
(將學習板上89c52對應的IO接點接到 STC15W201S IO口上)

IO腳位定義:定義3個io口為電平輸入(低電平觸發)端口,
           P5.5 = R
           P5.4 = L
           P3.2 = C         

           定義6個io口為輸出控制口(LED),
           P1.0 ~ P1.5
         
程序說明: 3個輸入上電後檢測低電平觸發 (將學習板上的接地引腳做低電平信號),3個輸入不同組合,對應輸出數組動作
問題說明:以下程序是參考百度上有人寫的按鍵檢測程序而修改的,而輸入端如果是只有1個或2個同時低電平,所對應
               輸出數組動作是正常的,但是到最後如果3個輸入同時都是低電平就不會動作了,像是卡住不動了

請教前輩們,想請程序問題和電路硬件問題?
程序: 下面程序是否有瑕疵不完善,改如何修改,或者有更好的寫法;

硬體電路:因為載學習板上是拉接地端引腳當地電平信號,但實際電路輸入是DC12V,
               請問是否可接8050NPN三極管及電組做反相電路,可以的話要怎麼接電阻值該取多少?

不好意思,問題敘述及程序有點亂,如果看得吃力,請見諒,懇請解惑,謝謝


  1. #include<reg52.h>               
  2. #define uchar unsigned char
  3. #define uint unsigned int  

  5. unsigned char code segR[]={
  6.                                                         0xff,0xdf,0xcf,0x07,0xc3,0xc1,0xc0,0xc0,
  7.                                                         0xe0,0xf0,0xf8,0xfc,0xfe,0xff
  8.                                                   };

  10. unsigned char code segL[]={
  11.                                                         0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0xc0,
  12.                                                         0xc1,0xc3,0xc7,0xcf,0xdf,0xff
  13.                                                   };

  15. unsigned char code segC[]={
  16.                                                         0xff,0xc0,0xff,0xc0                                                        
  17.                                                   };

  19. unsigned char code segCR[]={
  20.                                                         0xc7,0xc3,0xc1,0xc0,0xc0,
  21.                                                         0xc4,0xc6,0xc7                                                        
  22.                                                   };

  24. unsigned char code segCL[]={
  25.                                                         0xf8,0xf0,0xe0,0xc0,0xc0,
  26.                                                         0xc8,0xd8,0xf8                                                        
  27.                                                    };

  29. unsigned char code segRL[]={
  30.                                                         0xff,0xf3,0xe1,0xc0,0xc0,
  31.                                                         0xcc,0xde,0xff                                                        
  32.                                                     };

  34. unsigned char code segCRL[]={
  35.                                                         0xff,0xf3,0xe1,0xc0,0xc0,
  36.                                                         0xcc,0xde,0xff                                                        
  37.                                                     };


  40. sbit P1_0=P1^0;
  41. sbit P1_1=P1^1;
  42. sbit P1_2=P1^2;
  43. sbit P1_3=P1^3;
  44. sbit P1_4=P1^4;
  45. sbit P1_5=P1^5;

  47. sbit C_key=P3^2;
  48. sbit L_key=P5^4;
  49. sbit R_key=P5^5;

  51. void Delay1(uchar tt);

  53. void key()
  54. {

  56.          uchar i,k;
  57.          P1=0xff;

  59.         if(R_key==0 && L_key==1 && C_key==1)
  60.         {
  61. //                P1=0xc7;
  62.                 Delay1(10);
  63.                 if(R_key==0 && L_key==1 && C_key==1)
  64.                 {
  65.                         for(k=0;k<1;k++)
  66.                 {
  67.                                    
  68.                          for(i=0;i<14;i++)
  69.                              {
  70.                                                          
  71.                                          Delay1(50);
  72.                                  P1=segR[i];
  73.                                        
  74.                  
  75.                          }
  76.                                  while(R_key==1 && L_key==1 && C_key==1);                                 
  77.                                  break;                                
  78.                 }        
  79.                 }

  81.                 Delay1(10);
  82.                 while(!R_key && !L_key && !C_key);
  83. //                P1=0xff;
  84. //                break;                        
  85.         }

  87.         if(R_key==1 && L_key==0 && C_key==1)
  88.         {
  89. //                P1=0xf8;
  90.                 Delay1(10);
  91.                 if(R_key==1 && L_key==0 && C_key==1)
  92.                 {
  93.                         for(k=0;k<1;k++)
  94.                 {
  95.                                    
  96.                          for(i=0;i<14;i++)
  97.                              {
  98.                                                          
  99.                                          Delay1(50);
  100.                                  P1=segL[i];
  101.                                        
  102.                  
  103.                          }
  104. //                                 while(!L_key && R_key==1 && C_key==1);
  105. //                                 P1=0xff;
  106. //                                 break;                                
  107.                 }        
  108.                 }
  109.                         Delay1(10);
  110.                         while(!L_key && !R_key && !C_key);
  111. //                        P1=0xff;
  112. //                         break;        
  113.         }

  115.         if(R_key==0 && L_key==0 && C_key==1)
  116.         {
  117.                 P1=0xff;
  118.                 Delay1(10);
  119.                 if(R_key==0 && L_key==0 && C_key==1)
  120.                 {
  121.                         for(k=0;k<1;k++)
  122.                 {
  123.                                    
  124.                          for(i=0;i<8;i++)
  125.                              {
  126.                                                          
  127.                                          Delay1(50);
  128.                                  P1=segRL[i];
  129.                                        
  130.                  
  131.                          }
  132. //                                 while(!L_key && !R_key && C_key==1);
  133. //                                 P1=0xff;
  134. //                                 break;                                
  135.                 }               
  136.                 }
  137.                         Delay1(10);
  138.                         while(!L_key && !R_key && !C_key);
  139. //                        P1=0xff;
  140. //                         break;        
  141.         }

  143.         if(R_key==0 && L_key==1 && C_key==0)
  144.         {
  145.                 P1=0xc7;
  146.                 Delay1(10);
  147.                 if(R_key==0 && L_key==1 && C_key==0)
  148.                 {
  149.                         for(k=0;k<1;k++)
  150.                 {
  151.                                    
  152.                          for(i=0;i<8;i++)
  153.                              {
  154.                                                          
  155.                                          Delay1(50);
  156.                                  P1=segCR[i];
  157.                                        
  158.                  
  159.                          }
  160. //                                 while(!R_key && !L_key && !C_key);                                 
  161. //                                 break;                                
  162.                 }        
  163.                 }

  165.                 Delay1(10);
  166.                 while(!R_key && !L_key && !C_key);
  167. //                P1=0xff;
  168. //                break;                        
  169.         }

  171.         if(R_key==1 && L_key==0 && C_key==0)
  172.         {
  173.                 P1=0xf8;
  174.                 Delay1(10);
  175.                 if(R_key==1 && L_key==0 && C_key==0)
  176.                 {
  177.                         for(k=0;k<1;k++)
  178.                 {
  179.                                    
  180.                          for(i=0;i<8;i++)
  181.                              {
  182.                                                          
  183.                                          Delay1(50);
  184.                                  P1=segCL[i];
  185.                                        
  186.                  
  187.                          }
  188. //                                 while(!R_key && !L_key && !C_key);                                 
  189. //                                 break;                                
  190.                 }        
  191.                 }

  193.                 Delay1(10);
  194.                 while(!R_key && !L_key && !C_key);
  195. //                P1=0xff;
  196. //                break;                        
  197.         }

  199.         if(R_key==1 && L_key==1 && C_key==0)
  200.         {
  201.                 P1=0x00;
  202.                 Delay1(10);
  203.                 if(R_key==1 && L_key==1 && C_key==0)
  204.                 {
  205.                         for(k=0;k<1;k++)
  206.                 {
  207.                                    
  208.                          for(i=0;i<4;i++)
  209.                              {
  210.                                                          
  211.                                          Delay1(50);
  212.                                  P1=segC[i];
  213.                                        
  214.                  
  215.                          }
  216. //                                 while(!R_key && !L_key && !C_key);                                 
  217. //                                 break;                                
  218.                 }        
  219.                 }

  221.                 Delay1(10);
  222.                 while(!R_key && !L_key && !C_key);
  223. //                P1=0xff;
  224. //                break;                        
  225.         }

  227.         if(R_key==0 && L_key==0 && C_key==0)
  228.         {
  229.                 P1=0x00;
  230.                 Delay1(10);
  231.                 if(R_key==0 && L_key==0 && C_key==0)
  232.                 {
  233.                         for(k=0;k<1;k++)
  234.                 {
  235.                                    
  236.                          for(i=0;i<8;i++)
  237.                              {
  238.                                                          
  239.                                          Delay1(50);
  240.                                  P1=segCRL[i];
  241.                                        
  242.                  
  243.                          }
  244. //                                 while(!R_key && !L_key && !C_key);                                 
  245. //                                 break;                                
  246.                 }        
  247.                 }

  249.                 Delay1(10);
  250.                 while(!R_key && !L_key && !C_key);
  251. //                P1=0xff;
  252. //                break;                        
  253.         }
  254. }




  259. void main()
  260. {
  261. //        uchar i,k;
  262.     P1=0xff;
  263.         C_key=1;
  264.         R_key=1;
  265.         L_key=1;

  267.         while(1)
  268.         {
  269.           key();
  270.         }
  271. }

  273. void Delay1(uchar tt)
  274. {
  275. uchar aa,bb;
  276.     for(;tt>0;tt--)
  277.         for(bb=38;bb>0;bb--)
  278.             for(aa=130;aa>0;aa--);
  279. }
复制代码


      
作者: karyboa    时间: 2017-8-24 16:03
沒有人遇到類似的問題嗎?
作者: jubaolun    时间: 2017-8-25 15:49
这种问题很简单，自己多看看视频。首先判断输入状况，然后做相应的输出。
作者: karyboa    时间: 2017-8-26 06:39
我知道依據輸入電平狀態做判斷，而依所輸入高低電平組合做相對應的輸出;但是我這個程序是只有1個或是2個輸入是低電平，對應輸出是正常動作的，而只有3個輸入同時是低電平是沒有動作，像是卡住，每組輸出程序寫法是一樣的，我的問題重點是"3個輸入同時是低電平是沒有動作
作者: wulin    时间: 2017-8-26 08:13
你用3个按键组合控制可以把3个键组合成一个8位函数，你程序框架不合理，按键和显示混在一起。要分开写。按键程序只须判断识别键操作并输出相应键值，显示程序根据键值做相应显示，互不干扰。给你写个程序参考，按键程序只需要判断一次就可以输出相应键值，已经过实物验证：
#include <STC15F2K60S2.H>
//#include<reg52.h>               
#define uint unsigned int
#define uchar unsigned char

sbit D0=P3^7;
sbit D1=P1^0;
sbit D2=P1^1;
sbit D3=P1^2;
sbit D4=P1^3;
sbit D5=P1^4;
sbit D6=P1^5;

sbit C_key=P3^2;
sbit L_key=P5^4;
sbit R_key=P5^5;

uchar num=7;                                                //键值变量声明

/*********把3个键组合成一个8位函数**********/
uchar PD()
{                                                                                //0X07:0000 0111
        uchar i;
        i=C_key;
        i=(i<<1)|L_key;
        i=(i<<1)|R_key;
        return i;
}
/**************按键扫描函数*******************/
void key_scan()
{
        static bit key_sign=0;                //按键自锁标志
        static uint count=0;                        //计数变量                       
        if(PD()!=0x07)                                 //判断PD()不等于0x07，说明有健按下
        {
                count++;                                                //消抖计数
                if(count>=1000)                        //代替延时程序，确认按键按下
                {
                        count=1000;                                //防止计数溢出
                        if(key_sign==0)                //按键自锁标志为0
                        {
                                key_sign=1;                        //按键自锁标志置1，防止重复读键
                                num=PD();                        //保存键值
                        }
                }
        }
        else
        {
                key_sign=0;                                        //按键自锁标志清0
                count=0;                                                //消抖计数清0
        }
}
/**************显示函数*******************/
void display()
{                                                                                //LED显示键值000~111共8个状态
        if(num==0)
        {
                D0=0;       
                D1=D2=D3=D4=D5=D6=1;
        }
        if(num==1)
        {
                D1=0;       
                D0=D2=D3=D4=D5=D6=1;       
        }
        if(num==2)
        {
                D2=0;
                D0=D1=D3=D4=D5=D6=1;
        }
        if(num==3)
        {
                D3=0;
                D0=D1=D2=D4=D5=D6=1;
        }
        if(num==4)
        {
                D4=0;
                D0=D1=D2=D3=D5=D6=1;       
        }
        if(num==5)
        {
                D5=0;
                D0=D1=D2=D3=D4=D6=1;
        }
        if(num==6)
        {
                D6=0;
                D0=D1=D2=D3=D4=D5=1;
        }
        if(num==7)
        {
                D0=D1=D2=D3=D4=D5=D6=1;                                                //不显示
        }
}
/**************主函数*****************/
void main()
{
        while(1)
        {
                key_scan();
                display();
        }
}
作者: lyl930429    时间: 2017-8-26 09:37
繁体字看不懂
作者: zl2168    时间: 2017-8-26 11:09
lyl930429 发表于 2017-8-26 09:37
繁体字看不懂

繁体字的，请去台湾货香港咨询。
作者: karyboa    时间: 2017-8-26 12:47
感谢各位前辈解惑，我回去再修改看看，另外我因为是用STC的单片机，所以才再这里发问，发问内容让大家看不懂，报歉
作者: wulin    时间: 2017-8-26 18:48
karyboa 发表于 2017-8-26 12:47
感谢各位前辈解惑，我回去再修改看看，另外我因为是用STC的单片机，所以才再这里发问，发问内容让大家看不 ...

给你写的程序试了吗？
作者: karyboa    时间: 2017-8-26 20:56
wulin 发表于 2017-8-26 08:13
你用3个按键组合控制可以把3个键组合成一个8位函数，你程序框架不合理，按键和显示混在一起。要分开写。按 ...

感谢你的解说指导,感谢
作者: karyboa    时间: 2017-8-26 22:23
wulin 发表于 2017-8-26 18:48
给你写的程序试了吗？

我刚回到家,正在测试
作者: karyboa    时间: 2017-8-26 22:58
wulin 发表于 2017-8-26 18:48
给你写的程序试了吗？

回报您寫的程序,测试了这个程序,是每组输入组合都可以对应不同的输出沒错,但是....我不需要按鍵锁定的功能;
也就是说,按键按下是低电平输入,放開是高电平输入的狀态,单片机一上电就一直檢测輸入电平输入的的变化,
不过谢谢你让我知道有這樣写法,让我上了一课,只是現在我不太了觧不同IO口 (P0,P1,P2.. )是怎麼组合成同一位址函数,如您程序里的
uchar PD()
{                                                                                //0X07:0000 0111
        uchar i;
        i=C_key;
        i=(i<<1)|L_key;
        i=(i<<1)|R_key;
        return i;
}
現在我知道修改方向了,再次感谢!
作者: wulin    时间: 2017-8-27 06:52
karyboa 发表于 2017-8-26 22:58
回报您寫的程序,测试了这个程序,是每组输入组合都可以对应不同的输出沒错,但是....我不需要按鍵锁定的功 ...

按你的需求改写了程序并有详细注释，应该看得明白。
#include <STC15F2K60S2.H>
//#include<reg52.h>               
#define uint unsigned int
#define uchar unsigned char

sbit D0=P3^7;
sbit D1=P1^0;
sbit D2=P1^1;
sbit D3=P1^2;
sbit D4=P1^3;
sbit D5=P1^4;
sbit D6=P1^5;

sbit C_key=P3^2;
sbit L_key=P5^4;
sbit R_key=P5^5;

/*********把3个键组合成一个8位函数**********/
uchar PD()                                //有返回值无参数函数
{
        uchar i;                         //声明一个8位临时变量i，0000 0000
        i=C_key;                                //读取C_key电平赋值与i，0000 000X
        i=(i<<1)|L_key;        //i左移一位0000 00X0，"按位或"读取C_key电平再赋值i，0000 00XX
        i=(i<<1)|R_key;        //i再左移一位0000 0XX0，"按位或"读取R_key电平再赋值i，0000 0XXX
        return i;                        //返回i值 0000 0XXX
}
/**************按键扫描函数*******************/
uchar key_scan()                                //有返回值无参数函数
{
        static uint count=0;                //计数变量                       
        uchar num;                                        //键值变量声明
        if(PD()!=0x07)                         //判断PD()不等于0x07，说明有健按下
        {
                count++;                                        //消抖计数
                if(count>=1000)                //代替延时程序，确认PD()!=0x07
                {
                        count=0;                                //消抖计数清0
                        num=PD();                        //保存键值
                        return num;                        //返回num值
                }
        }
        else return 0x07;                        //返回无键按下的值
}
/**************显示函数*******************/
void display(uchar x)
{                                                                                //LED显示键值000~111共8个状态
        if(x==0)
        {
                D0=0;       
                D1=D2=D3=D4=D5=D6=1;
        }
        if(x==1)
        {
                D1=0;       
                D0=D2=D3=D4=D5=D6=1;       
        }
        if(x==2)
        {
                D2=0;
                D0=D1=D3=D4=D5=D6=1;
        }
        if(x==3)
        {
                D3=0;
                D0=D1=D2=D4=D5=D6=1;
        }
        if(x==4)
        {
                D4=0;
                D0=D1=D2=D3=D5=D6=1;       
        }
        if(x==5)
        {
                D5=0;
                D0=D1=D2=D3=D4=D6=1;
        }
        if(x==6)
        {
                D6=0;
                D0=D1=D2=D3=D4=D5=1;
        }
        if(x==7)
        {
                D0=D1=D2=D3=D4=D5=D6=1;                                                //不显示
        }
}
/**************主函数*****************/
void main()
{
        while(1)
        {
                display(key_scan());                                //显示按键状态
        }
}
作者: wulin    时间: 2017-8-27 07:23
karyboa 发表于 2017-8-26 22:58
回报您寫的程序,测试了这个程序,是每组输入组合都可以对应不同的输出沒错,但是....我不需要按鍵锁定的功 ...

如果不是用按键代替，而是TTL电平触发，不考虑消抖还可以简化程序：

#include <STC15F2K60S2.H>
//#include<reg52.h>               
#define uint unsigned int
#define uchar unsigned char

sbit D0=P3^7;
sbit D1=P1^0;
sbit D2=P1^1;
sbit D3=P1^2;
sbit D4=P1^3;
sbit D5=P1^4;
sbit D6=P1^5;

sbit C_key=P3^2;
sbit L_key=P5^4;
sbit R_key=P5^5;

/*********把3个电平组合成一个8位函数**********/
uchar PD()                                //有返回值无参数函数
{
        uchar i;                         //声明一个8位临时变量i，0000 0000
        i=C_key;                                //读取C_key电平赋值与i，0000 000X
        i=(i<<1)|L_key;        //i左移一位0000 00X0，"按位或"读取C_key电平再赋值与i，0000 00XX
        i=(i<<1)|R_key;        //i再左移一位0000 0XX0，"按位或"读取R_key电平再赋值与i，0000 0XXX
        return i;                        //返回i值 0000 0XXX
}
/**************显示函数*******************/
void display(uchar x)
{                                                                                //LED显示电平组合值000~111共8个状态
        if(x==0)
        {
                D0=0;       
                D1=D2=D3=D4=D5=D6=1;
        }
        if(x==1)
        {
                D1=0;       
                D0=D2=D3=D4=D5=D6=1;       
        }
        if(x==2)
        {
                D2=0;
                D0=D1=D3=D4=D5=D6=1;
        }
        if(x==3)
        {
                D3=0;
                D0=D1=D2=D4=D5=D6=1;
        }
        if(x==4)
        {
                D4=0;
                D0=D1=D2=D3=D5=D6=1;       
        }
        if(x==5)
        {
                D5=0;
                D0=D1=D2=D3=D4=D6=1;
        }
        if(x==6)
        {
                D6=0;
                D0=D1=D2=D3=D4=D5=1;
        }
        if(x==7)
        {
                D0=D1=D2=D3=D4=D5=D6=1;                                                //不显示
        }
}
/**************主函数*****************/
void main()
{
        while(1)
        {
                display(PD());                                //显示TTL电平触发状态
        }
}
作者: karyboa    时间: 2017-8-27 10:18
wulin 发表于 2017-8-27 07:23
如果不是用按键代替，而是TTL电平触发，不考虑消抖还可以简化程序：

#include

太谢谢你的帮忙了，晚上回家后再修改测试，谢谢
作者: karyboa    时间: 2017-8-27 23:03
wulin 发表于 2017-8-27 07:23
如果不是用按键代替，而是TTL电平触发，不考虑消抖还可以简化程序：

#include

回報测试俢改后程序情況,另外先说声报歉,昨天带按键锁定的程序,当3个同时低电平時,输出也是沒有動作,(我是直接从接地端口拉一条綫來斶发输入端口的),所以昨天应该是我有一输入口沒觸发到接地信号,以致於還有输出信号产生,所以这3个程序測试結果,

"当3个同時低电平输入時,是沒有输出的 ( led 不会亮) "
作者: karyboa    时间: 2017-8-27 23:33
wulin 发表于 2017-8-27 07:23
如果不是用按键代替，而是TTL电平触发，不考虑消抖还可以简化程序：

#include

再次更正,是我太粗心了,是我一個输出io口沒接上led,那个输出口刚好是3個输入低电平的狀态,不好意思,是我沒注意,这樣就这程序修改成我要输出的狀态就可以了,最后再次感谢您熱心的教导幇忙,谢谢
作者: karyboa    时间: 2017-8-27 23:47
wulin 发表于 2017-8-27 07:23
如果不是用按键代替，而是TTL电平触发，不考虑消抖还可以简化程序：

#include

补充一奌 : 有按键消斗的程序编譯的時后出现
" TEST7.C(42): warning C291: not every exit path returns a value " 的警告
, 在程序的       else return 0x07;           //返回无键按下的值 " ,
雖然還是可以下载写入,但我不了觧为什麼?
作者: wulin    时间: 2017-8-28 08:38
karyboa 发表于 2017-8-27 23:47
补充一奌 : 有按键消斗的程序编譯的時后出现
" TEST7.C(42): warning C291: not every exit path retu ...

这可能是不同编译器出现的问题，实测删除else return 0x07;对程序功能无碍，但逻辑不十分严谨。
也可以改为，
      //else return 0x07;                       //返回无键按下的值
        if(PD()==0x07)
                return 0x07;                      //返回无键按下的值
作者: karyboa    时间: 2017-8-28 10:21
wulin 发表于 2017-8-28 08:38
这可能是不同编译器出现的问题，实测删除else return 0x07;对程序功能无碍，但逻辑不十分严谨。
也可以 ...

了解，感谢您的无私指导，谢谢
作者: tianqi911    时间: 2018-5-30 10:45
感谢wulin大神。您的程序我正在看。我提的弱智问题，还请您抽空提点下，谢谢。



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1