欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 求教，7個獨立按鍵都不在同一單片機IO上，狀態機按鍵檢測咋實現？ [打印本頁]
作者: bbxyliyang    時間: 2020-3-17 18:07
標題: 求教，7個獨立按鍵都不在同一單片機IO上，狀態機按鍵檢測咋實現？
7個獨立按鍵都不在同一IO上，狀態機按鍵檢測咋實現？
作者: bbxyliyang    時間: 2020-3-17 18:44
假如3個獨立按鍵，分別對應3個I/O，這3個I/O口分屬于P1、P2、P3的某個引腳，怎樣用狀態機的思路進行檢測，一個按鍵的已經會了，但怎樣用狀態機方法同時檢測3個按鍵的動作？另外如果是組合按鍵（2個或者3個同時按下才生效）又該怎樣處理？能否提供思路！！！
作者: lovexulu    時間: 2020-3-17 22:23
if（a&&b）or if（b&&c）多按鍵狀態判斷，各個IO的狀態判斷跟1個IO一樣的。
作者: 天地一微塵    時間: 2020-3-17 22:28
首先，單片機運行速度是很快的。你按一次按鈕的時間，單片機都檢測了一二十次了！不同同時檢測，挨個檢測也行！！要同時按下，用if語句：if（按鈕一按下）{if（按鈕二按下）{執行動作}}
作者: lovexulu    時間: 2020-3-18 18:56
天地一微塵 發表于 2020-3-17 22:28
首先，單片機運行速度是很快的。你按一次按鈕的時間，單片機都檢測了一二十次了！不同同時檢測，挨個檢測也 ...

樓主說的是在狀態機狀態下由狀態標志判斷。
作者: ldh119    時間: 2020-5-1 17:58
用位移將7個IO口狀態賦值到一個變量中
作者: TTQ001    時間: 2020-5-2 02:56
如果狀態機檢查基于時間，則必須在實時系統中的不同單芯片計算機之間同步時間。
作者: bbxyliyang    時間: 2020-7-25 12:47
// 按鍵
#define key_state_0 0
#define key_state_1 1
#define key_state_2 2
#define key_state_3 3
#define key_no 0
#define key_click 1
#define key_double 2
#define key_long 3
sbit KEY = P0^4;
sbit key1=P5^0;// 紅光
sbit key2=P3^0;//綠光開關
sbit key3=P0^2;        //藍
sbit key4=P4^0;        //白
sbit key5=P0^3; //加濕度
sbit key6=P5^2;//自動

static unsigned char key_read(void)
{
        static unsigned char key_state_buffer1 = key_state_0;
        static unsigned char key_timer_cnt1 = 0;
                static         unsigned char temp=0;
        unsigned char key_return = key_no;
       // unsigned char key;

        //key = KEY;  //read the I/O states

        switch(key_state_buffer1)
        {
                case key_state_0:
                        if((KEY == 0)||(key1 == 0)||(key2==0)||(key3==0)||(key4==0)||(key5==0)||(key6==0))
                         {  key_state_buffer1 = key_state_1; temp=0;
                                                         return 0;
                                                 }
                                //按鍵被按下，狀態轉換到按鍵消抖和確認狀態//
                        break;
                case key_state_1:
                        if(KEY== 0)
                        {
                                temp=1;
                                                            key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                //按鍵仍然處于按下狀態
                                //消抖完成，key_timer開始準備計時
                                //狀態切換到按下時間計時狀態
                        }
                                                else if(key1==0)
                                                {
                                                           temp=2;
                                                           // key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                                }
                                                else if(key2==0)
                                                {
                                                            temp=4;
                                                           // key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                                }
                                                else if(key3==0)
                                                {
                                                            temp=5;
                                                           // key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                                }
                                                else if(key4==0)
                                                {
                                                            temp=6;
                                                           // key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                                }
                                                else if(key5==0)
                                                {
                                                            temp=7;
                                                           // key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                                }
                                                else if(key6==0)
                                                {
                                                            temp=8;
                                                           // key_timer_cnt1 = 0;
                                key_state_buffer1 = key_state_2;
                                                }
                        else
                                                {
                                key_state_buffer1 = key_state_0; temp=0;
                                                }
                                //按鍵已經抬起，回到按鍵初始狀態
                        break;  //完成軟件消抖
                case key_state_2:
                                                 if((KEY == 0)||(key1 == 0)||(key2==0)||(key3==0)||(key4==0)||(key5==0)||(key6==0))
                                                {
                                                         key_state_buffer1 = key_state_2;
                                                         if(temp==1)
                                                         {
                                                                 if(++key_timer_cnt1 >= 100)  //按鍵繼續按下，計時超過1000ms
                                                                 {
                                                                    
                                        key_return = key_long;  //送回長按事件
                                        key_state_buffer1 = key_state_3;  //轉換到等待按鍵釋放狀態
                                                                 }
                                                          }
                                                }
                                                else
                                                {
                                                         key_return = temp;  //按鍵抬起，產生一次click操作
                             key_state_buffer1 = key_state_0;  //轉換到按鍵初始狀態
                                                }
                       /* if(KEY == 1)
                        {
                                key_return = key_click;  //按鍵抬起，產生一次click操作
                                key_state_buffer1 = key_state_0;  //轉換到按鍵初始狀態
                        }
                        else if(++key_timer_cnt1 >= 100)  //按鍵繼續按下，計時超過1000ms
                        {
                                key_return = key_long;  //送回長按事件
                                key_state_buffer1 = key_state_3;  //轉換到等待按鍵釋放狀態
                        } */
                        break;
                case key_state_3:  //等待按鍵釋放
                        if((KEY == 0)||(key1 == 0)||(key2==0)||(key3==0)||(key4==0)||(key5==0)||(key6==0)) //按鍵釋放
                                key_state_buffer1 = key_state_3;  //切回按鍵初始狀態
                                                 else //按鍵釋放
                                key_state_buffer1 = key_state_0;  //切回按鍵初始狀態
                        break;
        }
        return key_return;
}

作者: 權威人物    時間: 2020-7-27 17:23
有個東西叫寄存器，讀取IO口的寄存器，比如你7個IO同在P1，那么P1寄存器讀出來，對應位為1則為高電平，32自行研究，
作者: wulin    時間: 2020-7-28 09:28
bbxyliyang 發表于 2020-3-17 18:44
假如3個獨立按鍵，分別對應3個I/O，這3個I/O口分屬于P1、P2、P3的某個引腳，怎樣用狀態機的思路進行檢測， ...

給你寫一個示例程序，你按實際需要修改。

  1. #include <reg51.H>

  3. #define PD 0x80|(P1<<3&0x60)|(P2>>1&0x18)|(P3&0x07)//P1.2~3/P2.4~5/P3.0~2組合7個按鍵為1個字節數據

  5. unsigned char code table[]={//共陽數碼管段碼"0~f-."
  6.                 0xc0,0xf9,0xa4,0xb0,
  7.                 0x99,0x92,0x82,0xf8,
  8.                 0x80,0x90,0x88,0x83,
  9.                 0xc6,0xa1,0x86,0x8e,0xbf,0x7f};

  11. unsigned char KeySec=0;//鍵值變量

  13. //延時程序
  14. void delayms(unsigned int k)
  15. {
  16.         unsigned int i,j;
  17.         for(i=k;i>0;i--)
  18.                 for(j=110;j>0;j--);
  19. }

  21. //按鍵掃描
  22. void keyscan()
  23. {
  24.         static unsigned int count=0;//計數變量
  25.         static bit key_sign=0;     //按鍵狀態標志
  26.         unsigned char time;                        //臨時變量

  28.         if((PD&0xff)!= 0xff)//有按鍵按下
  29.         {
  30.                 count++;                //計數變量自加1
  31.                 if(count>500)
  32.                         count=501;//防止溢出

  34.                 if(count>10 && key_sign==0)//10ms消抖與按鍵狀態識別
  35.                 {//使用組合鍵要適當延長消抖時間
  36.                         key_sign=1;//確認按鍵按下
  37.                         time=PD&0xff;//保存鍵態值
  38.                 }
  39.                 if(count==500)//判斷按下0.5s長按有效
  40.                 {
  41.                         switch(time)
  42.                         {
  43.                                 //單鍵
  44.                                 case 0xfe: KeySec=8;  break;
  45.                                 case 0xfd: KeySec=9;  break;
  46.                                 case 0xfb: KeySec=10; break;
  47.                                 case 0xf7: KeySec=11; break;
  48.                                 case 0xef: KeySec=12; break;
  49.                                 case 0xdf: KeySec=13; break;
  50.                                 case 0xbf: KeySec=14; break;
  51.                         // 組合鍵
  52.                         //        case 0xee: KeySec=?; break;
  53.                         }
  54.                 }
  55.         }
  56.         else //沒有按或按下后松手
  57.         {
  58.                 if(key_sign==1)//判斷是按鍵按下后松手
  59.                 {
  60.                         key_sign=0; //按鍵狀態標志清0
  61.                         if(count>10 && count<500)//小于0.5s判斷為短按
  62.                         {
  63.                                 switch(time)
  64.                                 {
  65.                                         //單鍵
  66.                                         case 0xfe: KeySec=1; break;
  67.                                         case 0xfd: KeySec=2; break;
  68.                                         case 0xfb: KeySec=3; break;
  69.                                         case 0xf7: KeySec=4; break;
  70.                                         case 0xef: KeySec=5; break;
  71.                                         case 0xdf: KeySec=6; break;
  72.                                         case 0xbf: KeySec=7; break;
  73.                                 // 組合鍵
  74.                                 //        case 0xee: KeySec=?; break;
  75.                                 }
  76.                         }
  77.                 }
  78.                 count=0;//計數變量清0
  79.         }
  80. }
  81. //主函數
  82. void main()
  83. {
  84.         P0=table[KeySec];//初始顯示狀態0
  85.         while(1)
  86.         {
  87.                 keyscan();        //按鍵掃描
  88.                 if(KeySec!=0)//刷新顯示
  89.                 {
  90.                         P0=table[KeySec];//顯示鍵值
  91.                         KeySec=0;//鍵值清0
  92.                 }
  93.                 delayms(1);//控制主循環周期1ms
  94.         }
  95. }
復制代碼



作者: lxbhcy    時間: 2020-7-28 11:37
7個獨立按鍵狀態，直接放進一個8位的數據里面，最高位或者最低位不要
作者: bbxyliyang    時間: 2020-7-30 22:18
感覺狀態機應用比較廣，這個程序我已經學會了狀態的使用。
作者: xqleft    時間: 2020-7-31 09:29
7個獨立按鍵? 7個獨立IO口? 然后你就不知道怎么控制了?
作者: bbxyliyang    時間: 2020-7-31 11:52
xqleft 發表于 2020-7-31 09:29
7個獨立按鍵? 7個獨立IO口? 然后你就不知道怎么控制了?

已經學會了
作者: bbxyliyang    時間: 2020-7-31 19:11
有限狀態機由有限的狀態和相互之間的轉移構成，在任何時候只
能處于給定數目的狀態中的一個。當接收到一個輸入事件時，狀態機產生一個輸出，同時也可能伴隨著狀態的轉移。
#define key_input    PIND.7      // 按鍵輸入口
#define key_state_0  0
#define key_state_1  1
#define key_state_2  2
char read_key(void)
{
static char key_state = 0;
char key_press, key_return = 0;
key_press = key_input;        // 讀按鍵 I/O (狀態機的輸入)
switch (key_state)
{
case key_state_0:        // 按鍵初始態
        if (!key_press) key_state = key_state_1;  // 鍵被按下，狀態轉換到鍵確認態 , 確定下一次按鍵的狀態值
break;
case key_state_1:        // 按鍵確認態
if (!key_press)
{
            key_return = 1;      // 按鍵仍按下，按鍵確認輸出為“1”
            key_state = key_state_2;  // 狀態轉換到鍵釋放態
}
else
            key_state = key_state_0;  // 按鍵已抬起，轉換到 按鍵初始態
       break;
case key_state_2:
            if (key_press) key_state = key_state_0;  //按鍵已釋放，轉換到按鍵初始態
       break;
}  
      return key_return;
}
該簡單按鍵接口函數 read_key()在整個系統程序中應每隔10ms
調用執行一次，每次執行時將先讀取與按鍵連接的 I/O 的電平到變量 key_press 中，然后進入用 switch 結構構成的狀態機。switch 結構中的 case 語句分別實現了 3 個不同狀態的處理判別過程，在每個狀態中將根據狀態的不同，以及 key_press 的值（狀態機的輸入）確定輸出值（key_return），和確定下一次按鍵的狀態值（key_state） 。 函數 read_key()的返回參數提供上層程序使用。返回值為 0 時，表示按鍵無動作；而返回 1 表示有一次按鍵閉合動作，需要進入按鍵處理程序做相應的鍵處理。在函數 read_key()中定義了 3 個局部變量，其中 key_press和key_return為一般普通的局部變量，每次函數執行時，key_press 中保存著剛檢測的按鍵值。key_return 為函數的返回值，總是先初始化為 0，只有在狀態 1 中重新置 1，作為表示按鍵確認的標志返回。變量 key_state 非常重要，它保存著按鍵的狀態值，該變量的值在函數調用結束后不能消失，
必須保留原值，因此在程序中定義為“局部靜態變量” ，用static 聲明。如果使用的語言環境不支持 static 類型的局部變量，應將 key_state 定義為全局變量（關于局部靜態變量的特點請參考相關介紹 C 語言程序設計的書籍） 。
作者: bbxyliyang    時間: 2021-1-21 15:29
bbxyliyang 發表于 2020-7-30 22:18
感覺狀態機應用比較廣，這個程序我已經學會了狀態的使用。

對的，狀態機比較常見的。
作者: bbxyliyang    時間: 2021-6-14 19:39
xqleft 發表于 2020-7-31 09:29
7個獨立按鍵? 7個獨立IO口? 然后你就不知道怎么控制了?

知道控制



歡迎光臨 (http://m.raoushi.com/bbs/) Powered by Discuz! X3.1