21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › stc+adc按键+状态机，程序能运行，但按键切换时间可达40 ...
12
返回列表 发新帖我要提问

stc+adc按键+状态机，程序能运行，但按键切换时间可达40多秒，不知道哪里出错

[复制链接]
2176|31
 楼主| chen915 发表于 2020-9-11 11:44 | 显示全部楼层
ayb_ice 发表于 2020-9-9 08:30
定时去读按键，相邻的两次有变化（不是按下就是松开）就可以了，按键对定时也不敏感10~100MS均可 ...

多谢
回复

收藏 举报

 楼主| chen915 发表于 2020-9-11 11:50 | 显示全部楼层
复制
  1. /*******原程序**********/
    

  2. #include "stc12c5630ad.h"
    


  3. 

  4. typedef unsigned char u8 ; 
    

  5. typedef unsigned int u16 ; 
    


  6. 

  7. #define buzz                 P32
    

  8. #define led                 P31
    

  9. #define adc_key         P11 
    

  10. #define VCC                 5000
    


  11. 

  12. u8 aaa = 0 ; 
    

  13. u8 flag__key_scan ; 
    

  14. u8 key_number ; 
    

  15. u8 key_number_final ; 
    

  16. unsigned char flag1 , flag2 ;  //两个软定时标志位，前者为LED亮的时间段，后者为灭
    

  17. unsigned int soft_timer_counter  , led_on_time , led_off_time ; //软定时自增变量，led亮时间，LED灭时间
    

  18. typedef void (*VOID)(void) ;  //先定义函数指针
    

  19. VOID funtion_run ; 
    


  20. 

  21. void buzz_on(void)
    

  22. {
    

  23.         buzz = 1 ; 
    

  24. }
    


  25. 

  26. void buzz_off(void)
    

  27. {
    

  28.         buzz = 0 ; 
    

  29. }
    


  30. 

  31. void led_on(void)
    

  32. {
    

  33.         led = 0 ; 
    

  34. }
    


  35. 

  36. void led_off(void)
    

  37. {
    

  38.         led = 1 ; 
    

  39. }
    


  40. 

  41. void set_timer(u16 led_on_time_temp , u16 led_off_time_temp , VOID funtion1 , VOID funtion2) 
    

  42. {        //3、第一个参数为LED点亮时长，第二位灭时长，三为亮函数，四为灭函数
    

  43.         led_on_time = led_on_time_temp ; 
    

  44.         led_off_time = led_off_time_temp ;
    

  45.         
    

  46.         if(flag1 == 1)
    

  47.         {
    

  48.                 flag1 = 0 ; 
    

  49.                 funtion_run = funtion1 ; //指针指向亮函数
    

  50.                 funtion_run() ;                  //并运行所指向的函数
    

  51.         }
    

  52.         if(flag2 == 1)
    

  53.         {
    

  54.                 flag2 = 0 ;
    

  55.                 funtion_run = funtion2 ; //指针指向灭函数
    

  56.                 funtion_run() ;                  //并运行所指向的函数
    

  57.         }
    

  58. }
    

  59. /*******************************************************************************************************************************/
    

  60. //P1M0 , P1M1 , ADC_CONTR=[ADC_POWER][SPEED1][SPEED0][ADC_FLAG]    [ADC_START][CHS2][CHS1][CHS0]
    

  61. //ADC_DATA , ADC_LOW2，AUXR=[T0x12][T1x12][UART_M0x12][EADCI][ESPI][ELVDI][-][-],IE,IP,IPH
    

  62. /*******************************************************************************************************************************/
    

  63. #define adc_power_on (ADC_CONTR |= 0x80)
    

  64. #define adc_power_off (ADC_CONTR &= 0x7f)
    


  65. 

  66. #define adc_flag_set (ADC_CONTR |= 0x10)
    

  67. #define adc_flag_clear (ADC_CONTR &= 0xef)
    


  68. 

  69. #define adc_start_on (ADC_CONTR |= 0x08)
    

  70. #define adc_start_off (ADC_CONTR &= 0xf7)
    


  71. 

  72. enum key_number  //键值枚举声明
    

  73. {
    

  74.         key1 = 1 , key2 , 
    

  75.         key3 , key4 , 
    

  76.         key5 , key6 , 
    

  77.         key7 , key8 , 
    

  78.         key9 , key10  //代表未按下
    

  79. } ; 
    


  80. 

  81. enum key_statues //按键状态枚举，分别为初始状态，按下状态，确认按下状态，松手状态
    

  82. {
    

  83.         key_statues0 = 0 , //初始态 
    

  84.         key_statues1 = 1 , //按下态
    

  85.         key_statues2 ,     //确认按下态
    

  86.         key_statues3 ,                 //松手态
    

  87. } ;
    

  88. /*****************************************
    

  89. *****************************************/
    

  90. /*****************************************
    

  91. *****************************************/
    

  92. /*****************************************
    

  93. *****************************************/
    

  94. void adc_init(void) //ADC初始化
    

  95. {
    

  96.         ADC_CONTR = 0x61 ;  //0110 0001 //关adc，270个周期转换一次，关标志位，关闭启动位，选择1通道
    

  97.         adc_power_on ;         //重开adc
    

  98.         adc_start_on ;         //开启转换
    

  99.         adc_flag_clear ; //清adc转换标志位
    

  100. }
    


  101. 

  102. u16 adc_result()  //获取ADC值
    

  103. {
    

  104.         u16 result = 0 ; //32bit数据装载10bit的adc转换结果值 
    

  105.         u16 value = 0  ; 
    

  106.         adc_init() ;         
    


  107. 

  108.         while(!(ADC_CONTR & 0x10)) ;  //& 0001 0000，若是完成转换，则bit5为1，与上0x10，仍为1，再取反为0，则跳过改行执行下一行 
    

  109.         result = ADC_DATA*4 + ADC_LOW2 ; //ADC_DATA寄存器为8bit，左移两位，再加上ADC_LOW2的值，即可得到转换后完整的10bit结果
    

  110.         adc_flag_clear ; //清除ADC_FLAG标志位
    


  111. 

  112.         return result ; 
    

  113. }
    


  114. 

  115. u16 adc_hex2dec(float value) //16进制电压值转10进制，单位为mV毫伏
    

  116. {
    

  117.         float value_dec ; 
    

  118.         value_dec = (VCC * (value))/1024 ;        
    

  119.         
    

  120.         return (u16)value_dec ; 
    

  121. }
    


  122. 

  123. /*****************************************
    

  124. *  00 准双向io口                01 推挽输出
    

  125. *  10 高阻输入                  11 开漏
    

  126. *****************************************/
    

  127. void gpio_init()  //gpio初始化函数
    

  128. {
    

  129.         P1 = 0x02 ; //0000 0010 
    

  130.         P1M0 = 0x02 ; //0000 0010   
    

  131.         P1M1 = 0x00 ; //0000 0000  设置按键为输入
    

  132.         
    

  133.         P3 = 0x06 ; //0000 0110 
    

  134.         P3M0 = 0x00 ; //0000 0000  
    

  135.         P3M1 = 0x06 ; //0000 0110  设置蜂鸣器和LED为输出
    

  136. }
    


  137. 

  138. /*****************************************
    

  139. *****************************************/
    

  140. u8 adc_key_value_process(u16 adc_value)  //通过adc值定义键值并返回..........该函数有问题，需要对adc电压值进行更好的处理
    

  141. {
    

  142.         u16 temp_adc_value = adc_value ; //中间变量
    

  143.         temp_adc_value /= 100 ; //对100求模，若是需要更高精度，可改100为更小值
    

  144.         
    

  145.         switch (temp_adc_value) //temp_adc_value精度存在严重问题，建议再用一个switch语句判断键值，使电压值转化为0-10的数字
    

  146.         {
    

  147.                 case 41 :         //按键1按下电压值为4100mV左右
    

  148.                         return 1 ;    //返回1
    

  149.                 case 35 :
    

  150.                         return 2 ; 
    

  151.                 case 30 :
    

  152.                         return 3 ; 
    

  153.                 case 25 :
    

  154.                         return 4 ; 
    

  155.                 case 21 :
    

  156.                         return 5 ; 
    

  157.                 case 15 :
    

  158.                         return 6 ; 
    

  159.                 case 10 :
    

  160.                         return 7 ; 
    

  161.                 case 5 :
    

  162.                         return 8 ; 
    

  163.                 case 0 :
    

  164.                         return 9 ; 
    

  165.                 
    

  166.                 default :        //未按下，返回0
    

  167.                         return 0 ; 
    

  168.         }
    


  169. 

  170. /************************************************************************************************
    

  171. //                adc_value = adc_hex2dec(adc_result()) ; 
    

  172. //                if((adc_value>=0) && (adc_value<=5000)) //若是有按键按下，则按键对号 
    

  173. //                {
    

  174. //                        if(0 == adc_value) 
    

  175. //                                return 9;
    

  176. //                        else if((adc_value <  723)  && (adc_value >  323))  //+-200mV
    

  177. //                                return 8;
    

  178. //                        else if((adc_value < 1254)  && (adc_value >  854)) 
    

  179. //                                return 7;
    

  180. //                        else if((adc_value < 1742)  && (adc_value > 1342)) 
    

  181. //                                return 6;
    

  182. //                        else if((adc_value < 2338)  && (adc_value > 1938)) 
    

  183. //                                return 5;
    

  184. //                        else if((adc_value < 2778)  && (adc_value > 2378)) 
    

  185. //                                return 4;
    

  186. //                        else if((adc_value < 3237)  && (adc_value > 2837)) 
    

  187. //                                return 3;
    

  188. //                        else if((adc_value < 3793)  && (adc_value > 3393)) 
    

  189. //                                return 2;
    

  190. //                        else if((adc_value < 4306)  && (adc_value > 3906)) 
    

  191. //                                return 1;
    

  192. ////                        else if((adc_value <= 5000)  && (adc_value > 4795-244))  //无按键按下
    

  193. ////                                return 10;
    

  194. //                }
    

  195. //                else         //出错，则返回0
    

  196. //                {
    

  197. //                        return 0 ; 
    

  198. //                }
    

  199. **************************************************************************************************/
    

  200. }
    

  201. /*****************************************
    

  202. *****************************************/
    

  203. u8 key_scan(void) //状态机函数，返回状态机键值
    

  204. {
    

  205.                 static u8 key_statues = key_statues0 ; //相当于锁，函数运行前与运行完，都要置0
    

  206.                 static u8 adc_key_number_temp ; 
    

  207.                 u8 key_return ;        
    


  208. 

  209.                 adc_key_number_temp = adc_key_value_process(adc_hex2dec(adc_result())) ;//采集adc，并转化为键值
    

  210.                 key_number = adc_key_number_temp ; 
    

  211.                 switch(key_statues)
    

  212.                 {
    

  213.                         case key_statues0 : //初始态,也相当于锁
    

  214.                         {
    

  215.                                 if(0 != key_number) //若是有按键按下，则迁移至状态1------有按键按下时，key_number不会为0
    

  216.                                 {
    

  217.                                         key_statues = key_statues1 ; 
    

  218.                                 }
    

  219.                         }
    

  220.                         break ; 
    

  221.                         
    

  222.                         case key_statues1 : //按下态
    

  223.                         {
    

  224.                                 if(0 == key_number)        //如果只是抖动，则返回状态0
    

  225.                                 {
    

  226.                                         key_statues = key_statues0 ; 
    

  227.                                 }
    

  228.                                 
    

  229.                                 else
    

  230.                                 {
    

  231.                                         key_statues = key_statues2 ;  //若是确实有按下，则迁移到状态2
    

  232.                                         key_number_final = key_number ; //如果确实有按键按下，则保存先前的key_number值
    

  233. #if 0                                        
    

  234. //                                        switch (key_number)        //若是按下有效，则将代码段放在此处
    

  235. //                                        {
    

  236. //                                                case 9 :
    

  237. //                                                {
    

  238. //                                                        key_return = key9 ; 
    

  239. //                                                }
    

  240. //                                                break ; 
    

  241. //                                                
    

  242. //                                                case 8 :
    

  243. //                                                {
    

  244. //                                                        key_return = key8 ;
    

  245. //                                                }
    

  246. //                                                break ; 
    

  247. //                                                
    

  248. //                                                case 7 :
    

  249. //                                                {
    

  250. //                                                        key_return = key7 ;
    

  251. //                                                }
    

  252. //                                                break ; 
    

  253. //                                                
    

  254. //                                                case 6 :
    

  255. //                                                {
    

  256. //                                                        key_return = key6 ;
    

  257. //                                                }
    

  258. //                                                break ; 
    

  259. //                                                
    

  260. //                                                case 5 :
    

  261. //                                                {
    

  262. //                                                        key_return = key5 ;
    

  263. //                                                }
    

  264. //                                                break ; 
    

  265. //                                                
    

  266. //                                                case 4 :
    

  267. //                                                {
    

  268. //                                                        key_return = key4 ;
    

  269. //                                                }
    

  270. //                                                break ; 
    

  271. //                                                
    

  272. //                                                case 3 :
    

  273. //                                                {
    

  274. //                                                        key_return = key3 ;
    

  275. //                                                }
    

  276. //                                                break ; 
    

  277. //                                                
    

  278. //                                                case 2 :
    

  279. //                                                {
    

  280. //                                                        key_return = key2 ;
    

  281. //                                                }
    

  282. //                                                break ; 
    

  283. //                                                
    

  284. //                                                case 1 :
    

  285. //                                                {
    

  286. //                                                        key_return = key1 ;
    

  287. //                                                }
    

  288. //                                                break ; 
    

  289. //                                                
    

  290. ////                                                case 10 :        //该处移往松手态
    

  291. ////                                                {
    

  292. ////                                                        key_return = key10 ;        
    

  293. ////                                                }
    

  294. ////                                                break ;
    

  295. #endif
    

  296.                                 }
    

  297.                         }        
    

  298.                         break ; 
    

  299.                         
    

  300.                         case key_statues2 : //确认按下态，确认按下之后就应该判断是否松手，并进行消抖
    

  301.                         {
    

  302.                                 if(0 == key_number)                //若已松手，迁移至状态3，相当于松手消抖
    

  303.                                         key_statues = key_statues3 ; 
    

  304.                         }
    

  305.                         break ; 
    

  306.                         
    

  307.                         case key_statues3 : //松手态
    

  308.                         {
    

  309.                                 if(0 == key_number) //确实已经松手
    

  310.                                 {        
    

  311.                                         key_statues = key_statues0 ; //如果是确认无按键按下，则将状态迁移回状态0，即初始态。相当于自锁
    

  312. //                                        key_return = key10 ;        //松手返回key10
    

  313.                                         adc_key_number_temp = 0 ; 
    

  314.                                         
    

  315.                                         switch (key_number_final)        //松手后键值有效
    

  316.                                         {
    

  317.                                                 case 9 :
    

  318.                                                         key_return = key9 ; 
    

  319.                                                         break ; 
    

  320.                                                 
    

  321.                                                 case 8 :
    

  322.                                                         key_return = key8 ;
    

  323.                                                         break ; 
    

  324.                                                 
    

  325.                                                 case 7 :
    

  326.                                                         key_return = key7 ;
    

  327.                                                         break ; 
    

  328.                                                 
    

  329.                                                 case 6 :
    

  330.                                                         key_return = key6 ;
    

  331.                                                         break ; 
    

  332.                                                 
    

  333.                                                 case 5 :
    

  334.                                                         key_return = key5 ;
    

  335.                                                         break ; 
    

  336.                                                 
    

  337.                                                 case 4 :
    

  338.                                                         key_return = key4 ;
    

  339.                                                         break ; 
    

  340.                                                 
    

  341.                                                 case 3 :
    

  342.                                                         key_return = key3 ;
    

  343.                                                         break ; 
    

  344.                                                 
    

  345.                                                 case 2 :
    

  346.                                                         key_return = key2 ;
    

  347.                                                         break ; 
    

  348.                                                 
    

  349.                                                 case 1 :
    

  350.                                                         key_return = key1 ;
    

  351.                                                         break ; 
    

  352.                                                 
    

  353.                                                 case 0:
    

  354.                                                         key_return = key10 ;
    

  355.                                                         break ; 
    

  356.                                         }
    

  357.                                 }
    

  358.                                 else
    

  359.                                 {
    

  360.                                         key_statues = key_statues2 ; //否则回到状态2，即再判断一次
    

  361.                                 }
    

  362.                         }
    

  363.                         break ; 
    

  364.                 }
    

  365.         
    

  366.                 return key_return ; 
    

  367. }
    


  368. 

  369. void key_process(u8 key_return_number)
    

  370. {
    

  371. //        buzz_run(key_return_number) ;
    

  372. //  u8 i = 0 ;         
    

  373.         switch(key_return_number)
    

  374.         {
    

  375.                 case key1 : 
    

  376.                         set_timer(20 , 20 , led_on , led_off) ; 
    

  377.                         break ;
    

  378.                 
    

  379.                 case key2 :
    

  380.                         set_timer(60 , 60 , led_on , led_off) ; 
    

  381.                         break ; 
    

  382.                 
    

  383.                 case key3 :
    

  384.                         set_timer(200 , 200  , led_on , led_off) ; 
    

  385.                         break ; 
    

  386.                 
    

  387.                 case key4 :
    

  388.                         set_timer(1000 , 1000  , led_on , led_off) ; 
    

  389.                         break ; 
    

  390.                 
    

  391.                 case key5 :
    

  392.                         set_timer(2000 , 2000  , led_on , led_off) ; 
    

  393.                         break ; 
    

  394.                 
    

  395.                 case key6 :
    

  396.                         set_timer(3000 , 3000  , led_on , led_off) ; 
    

  397.                         break ; 
    

  398.                 
    

  399.                 case key7 :
    

  400.                         set_timer(4000 , 4000  , led_on , led_off) ; 
    

  401.                         break ; 
    

  402.                 
    

  403.                 case key8 :
    

  404.                         set_timer(5000 , 5000  , led_on , led_off) ; 
    

  405.                         break ; 
    

  406.                 
    

  407.                 case key9 :
    

  408.                         set_timer(6000 , 6000  , buzz_on , buzz_off) ; 
    

  409.                         break ; 
    

  410.         }
    

  411. }
    


  412. 

  413. /*****************************************
    

  414. *****************************************/
    

  415. void timer0_init(void)  //定时器0初始化
    

  416. {
    

  417.         TMOD = 0x01 ; 
    

  418.         TH0 = 0xfc ;  //1ms
    

  419.         TL0 = 0x66 ;
    

  420.         
    

  421.         ET0 = 1 ; 
    

  422.         EA = 1 ; 
    

  423.         
    

  424.         TR0 = 1 ; 
    

  425. }
    

  426. /*****************************************
    

  427. *****************************************/
    

  428. void main()
    

  429. {
    

  430.         P31 = 1 ;
    

  431.         gpio_init() ; 
    

  432.         timer0_init() ; 
    

  433.         adc_init() ; 
    

  434.         buzz = 0 ;
    

  435.         
    

  436. //        while(1)
    

  437. //                set_timer(6000 , 500 , led_on , led_off) ; 
    

  438.         
    

  439.         while(1)
    

  440.         {        
    

  441.                 key_process(aaa) ;
    

  442.         }        
    

  443. }
    

  444. /*****************************************
    

  445. *****************************************/
    

  446. void timer0_interrupt(void) interrupt 1  //定时器0中断函数，1ms中断
    

  447. {
    

  448.         static u16 tt = 0 ; 
    

  449.         
    

  450.         TH0 = 0xfc ; 
    

  451.         TL0 = 0x66 ; 
    

  452.         
    

  453.         tt++ ; 
    

  454.         soft_timer_counter++ ; 
    

  455.         if(tt == 10) //10ms进行一次扫描
    

  456.         {
    

  457.                 tt = 0 ; 
    

  458.                 flag__key_scan = 1 ; 
    

  459.                 aaa = key_scan() ; 
    

  460.         }        
    

  461.         if(soft_timer_counter >= (led_on_time+led_off_time)) //3、(led_on_time+led_off_time)是整个中断周期的时间，led_off_time在这里才现身
    

  462.                 soft_timer_counter = 0 ;         //清0        
    

  463.         if(soft_timer_counter < led_on_time)  //1、这两个if最为重要，若是小于，则置位flag1
    

  464.                 flag1 = 1 ;         
    

  465.         else        //2、否则，置位flag2，通过if和else组合，将一段时间一分为2，控制LED亮灭时间//注意，在此并未设置熄灭LED的时间长度，而是通过后面的led_off_time来控制
    

  466.                 flag2 = 1 ; 
    

  467. }
    


  468. 


  469. 


  470. 


  471. 


  472. 


  473. 


  474. 


  475. 


  476. 


  477. 


  478. 

  479. 结贴！！！！！！只改一条语句。。改if(soft_timer_counter == (led_on_time+led_off_time))为if(soft_timer_counter >= (led_on_time+led_off_time))。。。。。。。多谢各位耐心解答，谢谢！
回复

收藏 举报

 楼主| chen915 发表于 2020-9-11 11:58 | 显示全部楼层
chen915 发表于 2020-9-11 11:50

后续~~~~~~~~~~~~~~~~~~~~
为什么不能用 == 呢？
是因为一条C语言代码可能要运行好几条汇编代码，而导致的误差吗？
回复

收藏 举报

ayb_ice 发表于 2020-9-11 14:45 | 显示全部楼层
chen915 发表于 2020-9-11 11:50

这条代码我早就给你改过了，你没仔细看
回复

收藏 举报

 楼主| chen915 发表于 2020-9-11 15:53 | 显示全部楼层
ayb_ice 发表于 2020-9-11 14:45
这条代码我早就给你改过了，你没仔细看

好吧。当时只注意了标志位那部分，没全部复制粘贴。多谢。以后请多多支持啊。多谢
回复

收藏 举报

andy520520 发表于 2020-9-12 10:50 | 显示全部楼层
chen915 发表于 2020-8-28 17:11

印象中C51不支持3个以上的形参吧？
回复

收藏 举报

雪山飞狐D 发表于 2020-9-12 14:38 | 显示全部楼层
      设置一个全局最高优先级的定时器10ms , 做各种低紧急的查询任务，每隔10ms 查询一次按键状态，设置一个按键缓冲内存，三次按键都被按下说明没有抖动，这时才确定按键，这样做理论上不会有大冲突和延迟
回复

收藏 举报

 楼主| chen915 发表于 2020-9-13 22:27 | 显示全部楼层
雪山飞狐D 发表于 2020-9-12 14:38
设置一个全局最高优先级的定时器10ms , 做各种低紧急的查询任务，每隔10ms 查询一次按键状态，设置一 ...

嗯。谢谢。要是有代码就更好了现在的理解能力还离不开代码
回复

收藏 举报

 楼主| chen915 发表于 2020-9-13 22:27 | 显示全部楼层
andy520520 发表于 2020-9-12 10:50
印象中C51不支持3个以上的形参吧？

要怎样处理好一点？
回复

收藏 举报

雪山飞狐D 发表于 2020-9-14 05:35 | 显示全部楼层
chen915 发表于 2020-9-13 22:27
嗯。谢谢。要是有代码就更好了现在的理解能力还离不开代码

https://bbs.21ic.com/icview-2525970-1-1.html
我以前写的
回复

收藏 举报

 楼主| chen915 发表于 2020-9-14 08:43 | 显示全部楼层
雪山飞狐D 发表于 2020-9-14 05:35
https://bbs.21ic.com/icview-2525970-1-1.html
我以前写的

学习了，谢谢
回复

收藏 举报

ayb_ice 发表于 2020-9-14 09:11 | 显示全部楼层
andy520520 发表于 2020-9-12 10:50
印象中C51不支持3个以上的形参吧？

不是这样的，通过寄存器最多可以传递4个参数（取决于参数类型大小），其它参数通过固定内存传送，并没有什么限制
回复

收藏 举报

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

本版积分规则

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