key.c 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247
  1. #include "key.h"
  2. #include "delay.h"
  3. #include "bsp.h"
  4. key_status_t key_status[KEY_MAX];
  5. // timeout_t tt_key;
  6. key_para_t key_para[KEY_MAX];
  7. void key_init(void)
  8. {
  9. SYS_EnableAPBClock(APB_MASK_GPIO1);
  10. // SYS_DisableJTDO();
  11. GPIO_SetInput(GPIO1,0x70);
  12. key_status_init();
  13. // timeout_setValue(&tt_key,10,0xff);
  14. }
  15. //获取按键电平
  16. uint8_t get_key_bit(uint8_t key)
  17. {
  18. uint8_t status;
  19. switch (key)
  20. {
  21. case KEY1:
  22. status = GET_KEY1();
  23. break;
  24. case KEY2:
  25. status = GET_KEY2();
  26. break;
  27. case KEY3:
  28. status = GET_KEY3();
  29. break;
  30. default:
  31. status = 0;
  32. break;
  33. }
  34. return status;
  35. }
  36. /*!
  37. * \brief 上电读取按键电平
  38. * \param 无
  39. */
  40. void key_status_init(void)
  41. {
  42. int i;
  43. for(i = 0; i < KEY_MAX; i++)
  44. {
  45. key_status[i].last_level = get_key_bit(i);
  46. }
  47. }
  48. /*!
  49. * \brief 实时读取按键电平
  50. * \param 无
  51. */
  52. void get_key_bit_realtime(void)
  53. {
  54. int i;
  55. uint8_t status;
  56. // if(!timeout_isOut(&tt_key))
  57. // return;
  58. delay_ms(10);
  59. for(i = 0; i < KEY_MAX; i++)
  60. {
  61. status = get_key_bit(i);
  62. if(status != key_status[i].last_level)
  63. {
  64. key_status[i].flag = 1;
  65. if(status)//高电平 抬起
  66. {
  67. key_status[i].status = KEY_STATUS_UP;
  68. }
  69. else
  70. {
  71. key_status[i].status = KEY_STATUS_DN;
  72. }
  73. key_status[i].last_level = status;
  74. }
  75. }
  76. }
  77. /*!
  78. * \brief 按键处理函数
  79. * \param 无
  80. */
  81. void key_handle(void)
  82. {
  83. uint8_t i;
  84. get_key_bit_realtime();//实时读取按键电平
  85. for(i = 0; i < KEY_MAX; i++)
  86. {
  87. if(key_status[i].flag)
  88. {
  89. key_status[i].flag = 0;
  90. if(key_status[i].status == KEY_STATUS_UP)//抬起
  91. {
  92. // switch(i)
  93. // {
  94. // case KEY1:
  95. // // printf("key1 up\n");
  96. // break;
  97. // case KEY2:
  98. // // printf("key2 up\n");
  99. // // GPIO_SetHigh(ITSF_PWR_N_PORT,ITSF_PWR_N_BIT);
  100. // // YTSF_GPIO_REV4_EN();
  101. // // YTSF_GPIO_REV1_RST();
  102. // // delay_ms(500);
  103. // // YTSF_GPIO_REV1_SET();
  104. // break;
  105. // case KEY3:
  106. // // printf("key3 up\n");
  107. // // GPIO_SetHigh(ITSF_PWR_P_PORT,ITSF_PWR_N_BIT);
  108. // break;
  109. // default:
  110. // break;
  111. // }
  112. }
  113. else if(key_status[i].status == KEY_STATUS_DN)//按下
  114. {
  115. // if(key_para[i].flag==0)
  116. // {
  117. // key_para[i].flag = 1;
  118. // key_para[i].num = 0;
  119. // timeout_setValue(&key_para[i].tt_key,KEY_TIMEOUT,1);
  120. // }
  121. // key_para[i].num++;
  122. // printf("key%d,key num:%d\n",i+1,key_para[i].num);
  123. switch(i)
  124. {
  125. case KEY1:
  126. // ytsf_test();
  127. // lora_test();
  128. printf("key1 down\n");
  129. break;
  130. case KEY2:
  131. // tax_test();
  132. // SPI_FLASH_Test();
  133. // I2C_Test();
  134. printf("key2 down\n");
  135. // GPIO_SetLow(ITSF_PWR_N_PORT,ITSF_PWR_N_BIT);
  136. // YTSF_GPIO_REV4_DN();
  137. // SYS_SoftwareReset();
  138. // update_test();//升级测试
  139. // FLASH_Unlock();
  140. // FLASH_EraseSector(0x80020000);
  141. // FLASH_Lock();
  142. // printf("1\n");
  143. break;
  144. case KEY3:
  145. printf("key3 down\n");
  146. // GPIO_SetLow(ITSF_PWR_P_PORT,ITSF_PWR_N_BIT);
  147. break;
  148. default:
  149. break;
  150. }
  151. }
  152. }
  153. }
  154. // key_timeout_handle();
  155. }
  156. // //按键功能
  157. // void key_func(uint8_t key, uint8_t num)
  158. // {
  159. // printf("key%d,time%d,num%d\n",key+1,KEY_TIMEOUT,num);
  160. // switch(key)
  161. // {
  162. // case KEY1:
  163. // switch(num)
  164. // {
  165. // case 1:
  166. // // SPI_FLASH_Test();
  167. // // lora_send_query_firm(device_info.device_sn);//发送
  168. // break;
  169. // case 2:
  170. // // SX126xReset();
  171. // // lora_init();
  172. // // printf("lora reset\n");
  173. // break;
  174. // case 3://离线升级
  175. // // printf("lora index = %d\n",lora_para_choice);
  176. // device_fixed_info.master_updata_start = 1;
  177. // ota_state.offline_mode = KEY_TRIGGER;
  178. // break;
  179. // case 4:
  180. // // lora_power_init();
  181. // // lora_init();
  182. // break;
  183. // default:
  184. // break;
  185. // }
  186. // break;
  187. // case KEY2:
  188. // switch(num)
  189. // {
  190. // case 1:
  191. // break;
  192. // case 2:
  193. // break;
  194. // case 3:
  195. // device_fixed_info.master_updata_start = 1;
  196. // ota_state.offline_mode = KEY_TRIGGER;
  197. // break;
  198. // default:
  199. // break;
  200. // }
  201. // break;
  202. // case KEY3:
  203. // switch(num)
  204. // {
  205. // case 1:
  206. // break;
  207. // case 2:
  208. // break;
  209. // case 3:
  210. // break;
  211. // default:
  212. // break;
  213. // }
  214. // break;
  215. // default:
  216. // break;
  217. // }
  218. // }
  219. // //按键超时处理
  220. // void key_timeout_handle(void)
  221. // {
  222. // uint8_t i;
  223. // for(i = 0; i < KEY_MAX; i++)
  224. // {
  225. // if(timeout_isOut(&key_para[i].tt_key))
  226. // {
  227. // key_func(i,key_para[i].num);
  228. // key_para[i].flag = 0;
  229. // key_para[i].num = 0;
  230. // }
  231. // }
  232. // }