21ic电子技术开发论坛 › 单片机与嵌入式系统 › 沁恒USB蓝牙MCU › 触摸/轻触按键的长按和短按实现
返回列表 发新帖我要提问

[单片机芯片] 触摸/轻触按键的长按和短按实现

[复制链接]
3807|15
 楼主| lilijin1995 发表于 2023-7-6 10:23 | 显示全部楼层 |阅读模式
触摸, Button, I2c, MCU, Multi
本帖最后由 lilijin1995 于 2023-7-6 10:24 编辑

今天想和大家分享一个触摸/轻触按键的长按和短按实现；GitHub有好轮子MultiButton，本来我也想着直接套用，奈何MCU资源太有限，ROM是连Flash都没有的，是支持1000 次写操作MTP ；
实习参加工作时候有继承公司的一套I2C驱动触摸芯片代码如下：
复制
  1. //=============================================================================
    

  2. //Function：TK scan
    

  3. //Input：  null
    

  4. //Output： KeyCode
    

  5. //Remark： call every 10ms
    

  6. //=============================================================================
    

  7. UINT8 ctm_TKScan(void)
    

  8. {
    

  9.         volatile UINT16 TKStatue = 0;
    

  10.         volatile UINT8 TKStatue_L = 0;
    

  11.         volatile UINT8 TKStatue_H = 0;
    


  12. 

  13.         //Power delay 500ms, wait TK stable!
    

  14.         if( TKScan_PowerDelay <= 50 )
    

  15.         {        
    

  16.                 return 0;
    

  17.         }
    

  18.         
    

  19.         //clr keycode  
    

  20.         KeyCode = D_KeyNull;
    

  21.         
    

  22.         //backup "AnyKeyDn_Flag" statue
    

  23.         if( AnyKeyDn_Flag ){
    

  24.                 AnyKeyDnBuf_Flag = 1;}
    

  25.         else{
    

  26.                 AnyKeyDnBuf_Flag = 0;}
    

  27.         
    

  28.         //read key value
    

  29.         TKStatue_L = ctm_APT8L16_RdByte( R_K0_VR );                                //read key value        
    

  30.         TKStatue_H = ctm_APT8L16_RdByte( R_K1_VR );                                //read key value        
    

  31.         TKStatue = (((UINT16)TKStatue_H)<<8) + TKStatue_L;
    


  32. 

  33.         //key12 down
    

  34.         if( AnyKeyDn_Flag == 0 )
    

  35.         {
    

  36.                 //debonce
    

  37.                 if( (TKStatue & D_TK13) )
    

  38.                 {
    

  39.                         Key12_DCnt += 1;        
    

  40.                 }
    

  41.                 else
    

  42.                 {
    

  43.                         Key12_DCnt = 0;
    

  44.                 }
    

  45.                 //down
    

  46.                 if( Key12_DCnt >= D_KeyDCnt )
    

  47.                 {
    

  48.                         Key12_DCnt = 0;
    

  49.                         Key12Dn_Flag = 1;
    

  50.                         AnyKeyDn_Flag = 1;
    

  51.                 }
    

  52.         }
    


  53. 

  54.         //key11 down
    

  55.         if( AnyKeyDn_Flag == 0 )
    

  56.         {
    

  57.                 //debonce
    

  58.                 if( (TKStatue & D_TK12) )
    

  59.                 {
    

  60.                         Key11_DCnt += 1;        
    

  61.                 }
    

  62.                 else
    

  63.                 {
    

  64.                         Key11_DCnt = 0;
    

  65.                 }
    

  66.                 //down
    

  67.                 if( Key11_DCnt >= D_KeyDCnt )
    

  68.                 {
    

  69.                         Key11_DCnt = 0;
    

  70.                         Key11Dn_Flag = 1;
    

  71.                         AnyKeyDn_Flag = 1;
    

  72.                 }
    

  73.         }
    


  74. 

  75.         //key10 down
    

  76.         if( AnyKeyDn_Flag == 0 )
    

  77.         {
    

  78.                 //debonce
    

  79.                 if( (TKStatue & D_TK11) )
    

  80.                 {
    

  81.                         Key10_DCnt += 1;        
    

  82.                 }
    

  83.                 else
    

  84.                 {
    

  85.                         Key10_DCnt = 0;
    

  86.                 }
    

  87.                 //down
    

  88.                 if( Key10_DCnt >= D_KeyDCnt )
    

  89.                 {
    

  90.                         Key10_DCnt = 0;
    

  91.                         Key10Dn_Flag = 1;
    

  92.                         AnyKeyDn_Flag = 1;
    

  93.                 }
    

  94.         }
    


  95. 

  96.         //key9 down
    

  97.         if( AnyKeyDn_Flag == 0 )
    

  98.         {
    

  99.                 //debonce
    

  100.                 if( (TKStatue & D_TK10) )
    

  101.                 {
    

  102.                         Key9_DCnt += 1;        
    

  103.                 }
    

  104.                 else
    

  105.                 {
    

  106.                         Key9_DCnt = 0;
    

  107.                 }
    

  108.                 //down
    

  109.                 if( Key9_DCnt >= D_KeyDCnt )
    

  110.                 {
    

  111.                         Key9_DCnt = 0;
    

  112.                         Key9Dn_Flag = 1;
    

  113.                         AnyKeyDn_Flag = 1;
    

  114.                 }
    

  115.         }
    

  116.         
    

  117.         //key8 down
    

  118.         if( AnyKeyDn_Flag == 0 )
    

  119.         {
    

  120.                 //debonce
    

  121.                 if( (TKStatue & D_TK07) )
    

  122.                 {
    

  123.                         Key8_DCnt += 1;        
    

  124.                 }
    

  125.                 else
    

  126.                 {
    

  127.                         Key8_DCnt = 0;
    

  128.                 }
    

  129.                 //down
    

  130.                 if( Key8_DCnt >= D_KeyDCnt )
    

  131.                 {
    

  132.                         Key8_DCnt = 0;
    

  133.                         Key8Dn_Flag = 1;
    

  134.                         AnyKeyDn_Flag = 1;
    

  135.                 }
    

  136.         }
    


  137. 

  138.         //key7 down
    

  139.         if( AnyKeyDn_Flag == 0 )
    

  140.         {
    

  141.                 //debonce
    

  142.                 if( (TKStatue & D_TK06) )
    

  143.                 {
    

  144.                         Key7_DCnt += 1;        
    

  145.                 }
    

  146.                 else
    

  147.                 {
    

  148.                         Key7_DCnt = 0;
    

  149.                 }
    

  150.                 //down
    

  151.                 if( Key7_DCnt >= D_KeyDCnt )
    

  152.                 {
    

  153.                         Key7_DCnt = 0;
    

  154.                         Key7Dn_Flag = 1;
    

  155.                         AnyKeyDn_Flag = 1;
    

  156.                 }
    

  157.         }
    


  158. 

  159.         //key6 down
    

  160.         if( AnyKeyDn_Flag == 0 )
    

  161.         {
    

  162.                 //debonce
    

  163.                 if( (TKStatue & D_TK05) )
    

  164.                 {
    

  165.                         Key6_DCnt += 1;        
    

  166.                 }
    

  167.                 else
    

  168.                 {
    

  169.                         Key6_DCnt = 0;
    

  170.                 }
    

  171.                 //down
    

  172.                 if( Key6_DCnt >= D_KeyDCnt )
    

  173.                 {
    

  174.                         Key6_DCnt = 0;
    

  175.                         Key6Dn_Flag = 1;
    

  176.                         AnyKeyDn_Flag = 1;
    

  177.                 }
    

  178.         }
    


  179. 

  180.         //key5 down
    

  181.         if( AnyKeyDn_Flag == 0 )
    

  182.         {
    

  183.                 //debonce
    

  184.                 if( (TKStatue & D_TK04) )
    

  185.                 {
    

  186.                         Key5_DCnt += 1;        
    

  187.                 }
    

  188.                 else
    

  189.                 {
    

  190.                         Key5_DCnt = 0;
    

  191.                 }
    

  192.                 //down
    

  193.                 if( Key5_DCnt >= D_KeyDCnt )
    

  194.                 {
    

  195.                         Key5_DCnt = 0;
    

  196.                         Key5Dn_Flag = 1;
    

  197.                         AnyKeyDn_Flag = 1;
    

  198.                 }
    

  199.         }
    


  200. 

  201.         //key4 down
    

  202.         if( AnyKeyDn_Flag == 0 )
    

  203.         {
    

  204.                 //debonce
    

  205.                 if( (TKStatue & D_TK03) )
    

  206.                 {
    

  207.                         Key4_DCnt += 1;        
    

  208.                 }
    

  209.                 else
    

  210.                 {
    

  211.                         Key4_DCnt = 0;
    

  212.                 }
    

  213.                 //down
    

  214.                 if( Key4_DCnt >= D_KeyDCnt )
    

  215.                 {
    

  216.                         Key4_DCnt = 0;
    

  217.                         Key4Dn_Flag = 1;
    

  218.                         AnyKeyDn_Flag = 1;
    

  219.                 }
    

  220.         }
    

  221.         
    

  222.         //key3 down
    

  223.         if( AnyKeyDn_Flag == 0 )
    

  224.         {
    

  225.                 //debonce
    

  226.                 if( (TKStatue & D_TK02) )
    

  227.                 {
    

  228.                         Key3_DCnt += 1;        
    

  229.                 }
    

  230.                 else
    

  231.                 {
    

  232.                         Key3_DCnt = 0;
    

  233.                 }
    

  234.                 //down
    

  235.                 if( Key3_DCnt >= D_KeyDCnt )
    

  236.                 {
    

  237.                         Key3_DCnt = 0;
    

  238.                         Key3Dn_Flag = 1;
    

  239.                         AnyKeyDn_Flag = 1;
    

  240.                 }
    

  241.         }
    


  242. 

  243.         //key2 down
    

  244.         if( AnyKeyDn_Flag == 0 )
    

  245.         {
    

  246.                 //debonce
    

  247.                 if( (TKStatue & D_TK01) )
    

  248.                 {
    

  249.                         Key2_DCnt += 1;        
    

  250.                 }
    

  251.                 else
    

  252.                 {
    

  253.                         Key2_DCnt = 0;
    

  254.                 }
    

  255.                 //down
    

  256.                 if( Key2_DCnt >= D_KeyDCnt )
    

  257.                 {
    

  258.                         Key2_DCnt = 0;
    

  259.                         Key2Dn_Flag = 1;
    

  260.                         AnyKeyDn_Flag = 1;
    

  261.                 }
    

  262.         }        
    

  263.         
    

  264.         //key1 down
    

  265.         if( AnyKeyDn_Flag == 0 )
    

  266.         {
    

  267.                 //debonce
    

  268.                 if( (TKStatue & D_TK00) )
    

  269.                 {
    

  270.                         Key1_DCnt += 1;        
    

  271.                 }
    

  272.                 else
    

  273.                 {
    

  274.                         Key1_DCnt = 0;
    

  275.                 }
    

  276.                 //down
    

  277.                 if( Key1_DCnt >= D_KeyDCnt )
    

  278.                 {
    

  279.                         Key1_DCnt = 0;
    

  280.                         Key1Dn_Flag = 1;
    

  281.                         AnyKeyDn_Flag = 1;
    

  282.                 }
    

  283.         }        
    


  284. 


  285. 

  286.         //key12 long down                
    

  287.         if( Key12Dn_Flag && (Key12LDn_Flag==0) )
    

  288.         {
    

  289.                 Key12_LDCnt += 1;
    

  290.                 if( Key12_LDCnt >= 500 )                                //500*10ms=5s
    

  291.                 {
    

  292.                         Key12_LDCnt = 0;
    

  293.                         Key12LDn_Flag = 1;
    

  294.                         KeyCode = D_KeyAuto02LD;
    

  295.                 }
    

  296.         }
    

  297.         else
    

  298.         {
    

  299.                 Key12_LDCnt = 0;        
    

  300.         }
    


  301. 

  302.         //key11 long down                
    

  303.         if( Key11Dn_Flag && (Key11LDn_Flag==0) )
    

  304.         {
    

  305.                 Key11_LDCnt += 1;
    

  306.                 if( Key11_LDCnt >= 500 )                                //500*10ms=5s
    

  307.                 {
    

  308.                         Key11_LDCnt = 0;
    

  309.                         Key11LDn_Flag = 1;
    

  310.                         KeyCode = D_KeyAuto01LD;
    

  311.                 }
    

  312.         }
    

  313.         else
    

  314.         {
    

  315.                 Key11_LDCnt = 0;        
    

  316.         }
    


  317. 

  318.         //key10 long down                
    

  319.         if( Key10Dn_Flag && (Key10LDn_Flag==0) )
    

  320.         {
    

  321.                 Key10_LDCnt += 1;
    

  322.                 if( Key10_LDCnt >= 500 )                                //500*10ms=5s
    

  323.                 {
    

  324.                         Key10_LDCnt = 0;
    

  325.                         Key10LDn_Flag = 1;
    

  326.                         KeyCode = D_KeyPowerLD;
    

  327.                 }
    

  328.         }
    

  329.         else
    

  330.         {
    

  331.                 Key10_LDCnt = 0;        
    

  332.         }
    


  333. 

  334.         //key9 long down                
    

  335.         if( Key9Dn_Flag && (Key9LDn_Flag==0) )
    

  336.         {
    

  337.                 Key9_LDCnt += 1;
    

  338.                 if( Key9_LDCnt >= 500 )                                //500*10ms=5s
    

  339.                 {
    

  340.                         Key9_LDCnt = 0;
    

  341.                         Key9LDn_Flag = 1;
    

  342.                         KeyCode = D_KeyAmountLD;
    

  343.                 }
    

  344.         }
    

  345.         else
    

  346.         {
    

  347.                 Key9_LDCnt = 0;        
    

  348.         }
    

  349.         
    

  350.         //key8 long down                
    

  351.         if( Key8Dn_Flag && (Key8LDn_Flag==0) )
    

  352.         {
    

  353.                 Key8_LDCnt += 1;
    

  354.                 if( Key8_LDCnt >= 500 )                                //500*10ms=5s                        
    

  355.                 {
    

  356.                         Key8_LDCnt = 0;
    

  357.                         Key8LDn_Flag = 1;
    

  358.                         KeyCode = D_KeyTimerLD;
    

  359.                 }
    

  360.         }
    

  361.         else
    

  362.         {
    

  363.                 Key8_LDCnt = 0;        
    

  364.         }
    

  365.         
    

  366.         //key7 long down                
    

  367.         if( Key7Dn_Flag && (Key7LDn_Flag==0) )
    

  368.         {
    

  369.                 Key7_LDCnt += 1;
    

  370.                 if( Key7_LDCnt >= 500 )                                //500*10ms = 5s
    

  371.                 {
    

  372.                         Key7_LDCnt = 0;
    

  373.                         Key7LDn_Flag = 1;
    

  374.                         KeyCode = D_KeyUpLD;
    

  375.                 }
    

  376.         }
    

  377.         else
    

  378.         {
    

  379.                 Key7_LDCnt = 0;        
    

  380.         }
    

  381.         
    

  382.         //Key6 long down                
    

  383.         if( Key6Dn_Flag && (Key6LDn_Flag==0) )
    

  384.         {
    

  385.                 Key6_LDCnt += 1;
    

  386.                 if( Key6_LDCnt >= 500 )                                        //500*10ms = 5s
    

  387.                 {
    

  388.                         Key6_LDCnt = 0;
    

  389.                         Key6LDn_Flag = 1;
    

  390.                         KeyCode = D_KeyDownLD;
    

  391.                 }
    

  392.         }
    

  393.         else
    

  394.         {
    

  395.                 Key6_LDCnt = 0;        
    

  396.         }
    

  397.         
    

  398.         //key5 long down                
    

  399.         if( Key5Dn_Flag && (Key5LDn_Flag==0) )
    

  400.         {
    

  401.                 Key5_LDCnt += 1;
    

  402.                 if( Key5_LDCnt >= 500 )                                //500*10ms=5s
    

  403.                 {
    

  404.                         Key5_LDCnt = 0;
    

  405.                         Key5LDn_Flag = 1;
    

  406.                         KeyCode = D_KeyVersionLD;
    

  407.                 }
    

  408.         }
    

  409.         else
    

  410.         {
    

  411.                 Key5_LDCnt = 0;        
    

  412.         }
    

  413.         
    

  414.         //key4 long down                
    

  415.         if( Key4Dn_Flag && (Key4LDn_Flag==0) )
    

  416.         {
    

  417.                 Key4_LDCnt += 1;
    

  418.                 if( Key4_LDCnt >= 500 )                                //500*10ms=5s
    

  419.                 {
    

  420.                         Key4_LDCnt = 0;
    

  421.                         Key4LDn_Flag = 1;
    

  422.                         KeyCode = D_KeyWaterLD;
    

  423.                 }
    

  424.         }
    

  425.         else
    

  426.         {
    

  427.                 Key4_LDCnt = 0;        
    

  428.         }
    

  429.         
    

  430.         //key3 long down                
    

  431.         if( Key3Dn_Flag && (Key3LDn_Flag==0) )
    

  432.         {
    

  433.                 Key3_LDCnt += 1;
    

  434.                 if( Key3_LDCnt >= 500 )                                //500*10ms=5s
    

  435.                 {
    

  436.                         Key3_LDCnt = 0;
    

  437.                         Key3LDn_Flag = 1;
    

  438.                         KeyCode = D_KeyCleanLD;
    

  439.                 }
    

  440.         }
    

  441.         else
    

  442.         {
    

  443.                 Key3_LDCnt = 0;        
    

  444.         }
    

  445.         
    

  446.         //key2 long down                
    

  447.         if( Key2Dn_Flag && (Key2LDn_Flag==0) )
    

  448.         {
    

  449.                 Key2_LDCnt += 1;
    

  450.                 if( Key2_LDCnt >= 500 )                                //500*10ms=5s
    

  451.                 {
    

  452.                         Key2_LDCnt = 0;
    

  453.                         Key2LDn_Flag = 1;
    

  454.                         KeyCode = D_KeyHandLD;
    

  455.                 }
    

  456.         }
    

  457.         else
    

  458.         {
    

  459.                 Key2_LDCnt = 0;        
    

  460.         }
    

  461.         
    

  462.         //key1 long down                
    

  463.         if( Key1Dn_Flag && (Key1LDn_Flag==0) )
    

  464.         {
    

  465.                 Key1_LDCnt += 1;
    

  466.                 if( Key1_LDCnt >= 500 )                                //500*10ms=5s
    

  467.                 {
    

  468.                         Key1_LDCnt = 0;
    

  469.                         Key1LDn_Flag = 1;
    

  470.                         KeyCode = D_KeyContinueLD;
    

  471.                 }
    

  472.         }
    

  473.         else
    

  474.         {
    

  475.                 Key1_LDCnt = 0;        
    

  476.         }
    


  477. 

  478.         //all key release
    

  479.         if( AnyKeyDn_Flag && (TKStatue==0) )
    

  480.         {
    

  481.                 AllKeyRel_DCnt += 1;
    

  482.                 if( AllKeyRel_DCnt >= 3 )
    

  483.                 {
    

  484.                         //释放响应
    

  485.                         if( Key12Dn_Flag && (Key12LDn_Flag==0) ){        
    

  486.                                 KeyCode = D_KeyAuto02;        }
    

  487.                         if( Key11Dn_Flag && (Key11LDn_Flag==0) ){        
    

  488.                                 KeyCode = D_KeyAuto01;        }
    

  489.                         if( Key10Dn_Flag && (Key10LDn_Flag==0) ){        
    

  490.                                 KeyCode = D_KeyPower;        }
    

  491.                         if( Key9Dn_Flag && (Key9LDn_Flag==0) ){        
    

  492.                                 KeyCode = D_KeyAmount;        }
    

  493.                         if( Key8Dn_Flag && (Key8LDn_Flag==0) ){                
    

  494.                                 KeyCode = D_KeyTimer;                }
    

  495.                         if( Key7Dn_Flag && (Key7LDn_Flag==0) ){        
    

  496.                                 KeyCode = D_KeyUp;        }
    

  497.                         if( Key6Dn_Flag && (Key6LDn_Flag==0) ){        
    

  498.                                 KeyCode = D_KeyDown; }
    

  499.                         if( Key5Dn_Flag && (Key5LDn_Flag==0) ){        
    

  500.                                 KeyCode = D_KeyVersion;        }
    

  501.                         if( Key4Dn_Flag && (Key4LDn_Flag==0) ){        
    

  502.                                 KeyCode = D_KeyWater;        }
    

  503.                         if( Key3Dn_Flag && (Key3LDn_Flag==0) ){        
    

  504.                                 KeyCode = D_KeyClean;}
    

  505.                         if( Key2Dn_Flag && (Key2LDn_Flag==0) ){        
    

  506.                                 KeyCode = D_KeyHand;        }
    

  507.                         if( Key1Dn_Flag && (Key1LDn_Flag==0) ){        
    

  508.                                 KeyCode = D_KeyContinue;        }
    

  509.                         
    

  510.                         //clr ram
    

  511.                         AnyKeyDn_Flag = 0;
    

  512.                         AllKeyRel_DCnt = 0;
    

  513.                         
    

  514.                         Key12Dn_Flag = 0;
    

  515.                         Key12LDn_Flag = 0;
    

  516.                         Key12_DCnt = 0;
    

  517.                         Key12_LDCnt = 0;
    


  518. 

  519.                         Key11Dn_Flag = 0;
    

  520.                         Key11LDn_Flag = 0;
    

  521.                         Key11_DCnt = 0;
    

  522.                         Key11_LDCnt = 0;
    

  523.                         
    

  524.                         Key10Dn_Flag = 0;
    

  525.                         Key10LDn_Flag = 0;
    

  526.                         Key10_DCnt = 0;
    

  527.                         Key10_LDCnt = 0;
    


  528. 

  529.                         Key9Dn_Flag = 0;
    

  530.                         Key9LDn_Flag = 0;
    

  531.                         Key9_DCnt = 0;
    

  532.                         Key9_LDCnt = 0;
    


  533. 

  534.                         Key8Dn_Flag = 0;
    

  535.                         Key8LDn_Flag = 0;
    

  536.                         Key8_DCnt = 0;
    

  537.                         Key8_LDCnt = 0;
    

  538.                         
    

  539.                         Key7Dn_Flag = 0;
    

  540.                         Key7LDn_Flag = 0;
    

  541.                         Key7_DCnt = 0;
    

  542.                         Key7_LDCnt = 0;
    


  543. 

  544.                         Key6Dn_Flag = 0;
    

  545.                         Key6LDn_Flag = 0;
    

  546.                         Key6_DCnt = 0;
    

  547.                         Key6_LDCnt = 0;
    


  548. 

  549.                         Key5Dn_Flag = 0;
    

  550.                         Key5LDn_Flag = 0;
    

  551.                         Key5_DCnt = 0;
    

  552.                         Key5_LDCnt = 0;
    


  553. 

  554.                         Key4Dn_Flag = 0;
    

  555.                         Key4LDn_Flag = 0;
    

  556.                         Key4_DCnt = 0;
    

  557.                         Key4_LDCnt = 0;
    


  558. 

  559.                         Key3Dn_Flag = 0;
    

  560.                         Key3LDn_Flag = 0;
    

  561.                         Key3_DCnt = 0;
    

  562.                         Key3_LDCnt = 0;
    


  563. 

  564.                         Key2Dn_Flag = 0;
    

  565.                         Key2LDn_Flag = 0;
    

  566.                         Key2_DCnt = 0;
    

  567.                         Key2_LDCnt = 0;
    


  568. 

  569.                         Key1Dn_Flag = 0;
    

  570.                         Key1LDn_Flag = 0;
    

  571.                         Key1_DCnt = 0;
    

  572.                         Key1_LDCnt = 0;                        
    

  573.                 }
    

  574.         }
    

  575.         else
    

  576.         {
    

  577.                 AllKeyRel_DCnt = 0;
    

  578.         }
    

  579.         
    

  580.         //every key down, beep 1
    

  581.         if( (AnyKeyDn_Flag==1) && (AnyKeyDnBuf_Flag==0) ){
    

  582.                 Set_BuzNum(1); }                                                                //beep 1
    

  583.         
    

  584.         return 1;                        
    

  585. }
这段代码支持12个触摸按键的，实现的效果是短按释放响应，长按5S响应，轮询周期是10ms；这段代码有个缺点是定义了很多散乱的全局变量，可以通过结构体去整合优化，可能看起来可读性更强；
接着分享我现在工作中遇到的，如下：
复制
  1. void User(void)
    

  2. {
    

  3.    static u8 bTouchKey = 0;
    

  4.    static u16 Touchtick = 0;
    

  5.    KeyCode = D_KeyNull;
    

  6.    if(TouchResult)                        //test
    

  7.    {
    

  8.       if(bTouchKey==0)
    

  9.       {
    

  10.          bTouchKey = 1;    
    


  11. 

  12.       }else if(bTouchKey==1)
    

  13.       {
    

  14.           Touchtick+=1;
    

  15.           if(Touchtick>=300)
    

  16.           {
    

  17.             Touchtick=0;
    

  18.             bTouchKey=2; 
    

  19.             
    

  20.            KeyCode=D_KeyLD;             
    

  21.           }
    

  22.       }  
    

  23.    }
    

  24.    else
    

  25.    {
    

  26.       if(bTouchKey==1)
    

  27.       {
    


  28. 

  29.          KeyCode=D_Key;         
    

  30.       }
    

  31.       bTouchKey = 0;
    

  32.       Touchtick=0;
    

  33.    }
    

  34. }
我们介绍一下这部分代码，bTouchKey是按键状态切换标志，Touchtick是长按计时tick，也是10ms轮询一次；KeyCode保存键码，区分长按短按；TouchResult是扫到按键触摸；
短按实现思路：
bTouchKey在按键按下赋1，表示按键按下，如果没有超时3S，那么释放掉会响应保存键值；
长按实现思路：
同上如果超时3S，bTouchKey赋值3，保存键值并响应；
以上就是这次分享的长按和短按的实现，代码也没有做优化，我相信各位大佬会有很多更加优秀的代码，这里抛砖引玉，**大家一起分享学习一下。

回复

收藏 举报

相关帖子
caigang13 发表于 2023-7-6 19:20 来自手机 | 显示全部楼层
用定时器计时器
回复

收藏 举报

Antecer 发表于 2023-7-7 12:28 | 显示全部楼层
地狱级的if判断链...
回复

收藏 举报

远方的家乡 发表于 2023-7-21 17:14 | 显示全部楼层
有点烦锁。不错的代码！
回复

收藏 举报

zerorobert 发表于 2023-8-3 22:04 | 显示全部楼层
MultiButton不错的。              
回复

收藏 举报

saservice 发表于 2023-8-3 22:47 | 显示全部楼层
如何修改代码的灵敏度？              
回复

收藏 举报

tpgf 发表于 2023-8-4 11:50 | 显示全部楼层
这个轻触按键的话 如何区别轻重呢
回复

收藏 举报

nawu 发表于 2023-8-4 12:14 | 显示全部楼层
硬件上需要连接压力传感器吗？
回复

收藏 举报

abotomson 发表于 2023-8-4 12:57 | 显示全部楼层
这个按键需要有什么要求呢              
回复

收藏 举报

hearstnorman323 发表于 2023-8-4 13:28 | 显示全部楼层
这个需要定时器判断的嘛              
回复

收藏 举报

linfelix 发表于 2023-8-4 13:38 | 显示全部楼层
可以实现连击的判断吗              
回复

收藏 举报

aoyi 发表于 2023-8-4 13:49 | 显示全部楼层
这种轻触的情况如何排除这种水流击打呢
回复

收藏 举报

zljiu 发表于 2023-8-4 14:40 | 显示全部楼层
if语句的分支着实有些多了啊
回复

收藏 举报

gwsan 发表于 2023-8-4 16:11 | 显示全部楼层
需要判断的内容和条件太多了 很容易就出现重复的地方
回复

收藏 举报

tfqi 发表于 2023-8-4 16:16 | 显示全部楼层
这个长按和短按必定是认为规定的
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

lilijin1995

56

主题

165

帖子

8

粉丝
快速回复 在线客服 返回列表 返回顶部