【Telink B91】1. B91入坑总结以及串口Demo测试
【Telink B91】2. 矩阵按键以及freeRTOS应用
【Telink B91】3. 硬件I2C驱动OLED
【Telink B91】4. 硬件I2C采集HS3003温湿度信息

前言

试用了一下B91的FreeRTOS以及矩阵按钮，本文将讲解如何使用矩阵按键结合freeRTOS实现按钮对LED的控制。

1 FreeRTOS

官方提供的SDK中有FreeRTOS的示例工程，本文就是在此基础上实现的矩阵按钮的控制代码。

关于SDK获取途径，可以参考我上一篇帖子：【Telink B91】1. B91入坑总结以及串口Demo测试

 1688799273773.png

如上图，选择Freertos_Demo可以验证对freeRTOS的应用。但是有以下事项需要注意：

官方提供的FreeRTOS的时钟配置有问题，并不精确，需要重新设置，打开3rd-party->freertos-V5->include->FreeRTOSConfig.h，并修改如下参数，因为时钟频率是24MHz。

 1688799422356.png


2 矩阵按钮控制

2.1 原理图

矩阵按钮的原理图如下，按钮两边分别连接到两个引脚上，构成了一组2X2的矩阵按钮。

 1688799619520.png


2.2 工作原理

矩阵按钮的两个方向：行和列分别连接到一个按钮的两边，所以就需要检测两次，先检测行引脚状态（列引脚设置为输出低，行引脚设置为输入），再检测列引脚状态（行引脚设置为输出低，列引脚设置为输入）就可以确定具体是哪个按钮按下了。

工作流程如下：

1. 设置TL_Key3和TL_Key4引脚为输出引脚，输出低电平；
2. 设置TL_Key1和TL_Key2引脚为输入，并且设置内部电阻拉高，用于检测引脚是否按下；此时，如果key1和key2被按下，TL_Key1都会检测到低电平，如果key3和key4任何一个按下，TL_Key2都会检测到低电平；
3. 如果上面检测到了TL_Key1或者TL_Key2为低电平，则说明有按钮被按下了，此时需要开始检测行引脚状态用于确实具体按下的引脚；
4. 设置TL_Key1和TL_Key1引脚为输出引脚，输出低电平；
5. 设置TL_Key3和TL_Key4引脚为输入，并且设置内部电阻拉高，用于检测引脚是否按下；此时，如果key1和key3被按下，TL_Key3都会检测到低电平，如果key2和key4任何一个按下，TL_Key4都会检测到低电平；

示例：

如果上述第2步检测到了TL_Key2为低电平，则说明Key3或者Key4被按下了（也可能同时按下）；如果第5步检测到了TL_Key3为低电平，则说明按下的按钮为Key3，如果低5步TL_Key3和TL_Key4都检测到了低电平，说明按钮Key3和Key4都按下了。

3 代码实现

从上面可以知道矩阵按钮的工作原理，现在就可以开始实现代码逻辑了，如下代码从兼容性的角度出发，考虑了后期扩展功能，所以稍微复杂了一点点。

3.1 LED引脚初始化

下面为LED的引脚初始化：

  1. /*
  2. @hehung
  3. 2023-7-8
  4. email: 1398660197@qq.com
  5. wechat: hehung95
  6. reproduced and please indicate the source @hehung
  7. */
  9. #include "app_led.h"
  12. // Initialize for Led driver
  13. void Led_Init(void)
  14. {
  15.     /* Initialize the GPIO of LEDs */
  16.     gpio_function_en(LED1);
  17.     gpio_output_en(LED1);
  18.     gpio_input_dis(LED1);
  20.     gpio_function_en(LED2);
  21.     gpio_output_en(LED2);
  22.     gpio_input_dis(LED2);
  24.     gpio_function_en(LED3);
  25.     gpio_output_en(LED3);
  26.     gpio_input_dis(LED3);
  28.     gpio_function_en(LED4);
  29.     gpio_output_en(LED4);
  30.     gpio_input_dis(LED4);
  31. }


3.2 按钮程序

下面为按键程序：

app_key.c

其中：

- Key_Scan为处理逻辑函数，可以在任务中调用这个函数即可
- 如果需要正确使用按钮按下功能或者释放功能，还需要注册相关的函数，需要自己先实现对应的按键按下或者释放对应的动作功能，并通过函数Key_InstallPressFunc以及Key_InstallReleaseFunc注册功能，下面会举例说明

  1. /*
  2. @hehung
  3. 2023-7-8
  4. email: 1398660197@qq.com
  5. wechat: hehung95
  6. reproduced and please indicate the source @hehung
  7. */
  9. #include "app_key.h"
  12. static key_status_t key_status[KEY_TOTAL_NUM] =
  13. {
  14.     KEY_RELEASED,
  15.     KEY_RELEASED,
  16.     KEY_RELEASED,
  17.     KEY_RELEASED
  18. };
  19. static key_status_t last_key_status[KEY_TOTAL_NUM] =
  20. {
  21.     KEY_RELEASED,
  22.     KEY_RELEASED,
  23.     KEY_RELEASED,
  24.     KEY_RELEASED
  25. };
  26. static Key_Func key_press_func[KEY_TOTAL_NUM] =
  27. {
  28.     NULL,
  29.     NULL,
  30.     NULL,
  31.     NULL
  32. };
  33. static Key_Func key_release_func[KEY_TOTAL_NUM] =
  34. {
  35.     NULL,
  36.     NULL,
  37.     NULL,
  38.     NULL
  39. };
  42. static void Key_InitOutput(gpio_pin_e key);
  43. static void Key_InitInput(gpio_pin_e key);
  44. static void Key_StatusJudge(key_num_t key);
  47. static void Key_InitOutput(gpio_pin_e key)
  48. {
  49.     gpio_function_en(key);
  50.     gpio_output_en(key);
  51.     gpio_set_low_level(key);
  52. }
  54. static void Key_InitInput(gpio_pin_e key)
  55. {
  56.     gpio_function_en(key);
  57.     gpio_output_dis(key);
  58.     gpio_input_en(key);
  59.     gpio_set_up_down_res(key, GPIO_PIN_PULLUP_10K);
  60. }
  63. static void Key_StatusJudge(key_num_t key)
  64. {
  65.     if ((KEY_PRESSED == key_status[key]) && (KEY_RELEASED == last_key_status[key]))
  66.     {
  67.         // pressed
  68.         if (key_press_func[key] != NULL)
  69.         {
  70.             key_press_func[key]();
  71.         }
  72.     }
  73.     else if ((KEY_PRESSED == key_status[key]) && (KEY_PRESSED == last_key_status[key]))
  74.     {
  75.         // keep pressing: TODO
  76.     }
  77.     else if ((KEY_RELEASED == key_status[key]) && (KEY_PRESSED == last_key_status[key]))
  78.     {
  79.         // released
  80.         if (key_release_func[key] != NULL)
  81.         {
  82.             key_release_func[key]();
  83.         }
  84.     }
  85.     else
  86.     {
  87.         // keep releasing: TODO
  88.     }
  90.     last_key_status[key] = key_status[key];
  91. }
  93. // matrix key scan logic
  94. void Key_Scan(void)
  95. {
  96.     uint8_t key_pending = 0xFF;
  98.     //clear all key status
  99.     key_status[KEY_NUM1] = KEY_RELEASED;
  100.     key_status[KEY_NUM2] = KEY_RELEASED;
  101.     key_status[KEY_NUM3] = KEY_RELEASED;
  102.     key_status[KEY_NUM4] = KEY_RELEASED;
  104.     // scan column
  105.     // Key3 and Key4 output low used for as base volt for check KEY1 and KEY2
  106.     Key_InitOutput(KEY3);
  107.     Key_InitOutput(KEY4);
  109.     // KEY1 and KEY2 as output used for check button pressed signals
  110.     Key_InitInput(KEY1);
  111.     Key_InitInput(KEY2);
  113.     if ((0 == gpio_get_level(KEY1)) || (0 == gpio_get_level(KEY2)))
  114.     {
  115.         //filer: TODO
  116.         if (0 == gpio_get_level(KEY1))
  117.         {
  118.             key_pending = 0x00;
  119.         }
  120.         else
  121.         {
  122.             key_pending = 0x01;
  123.         }
  124.         // Scan row
  125.         // Key1 and Key2 output low used for as base volt for check KEY3 and KEY4
  126.         Key_InitOutput(KEY1);
  127.         Key_InitOutput(KEY2);
  129.         // KEY3 and KEY4 as output used for check button pressed signals
  130.         Key_InitInput(KEY3);
  131.         Key_InitInput(KEY4);
  133.         if ((0 == gpio_get_level(KEY3)) || (0 == gpio_get_level(KEY4)))
  134.         {
  135.             // filter: TODO
  136.             if (0 == gpio_get_level(KEY3))
  137.             {
  138.                 key_pending |= 0x00;
  139.             }
  140.             else
  141.             {
  142.                 key_pending |= 0x10;
  143.             }
  144.         }
  145.     }
  147.     switch (key_pending)
  148.     {
  149.         case 0x00: key_status[KEY_NUM1] = KEY_PRESSED; break;
  150.         case 0x01: key_status[KEY_NUM3] = KEY_PRESSED; break;
  151.         case 0x10: key_status[KEY_NUM2] = KEY_PRESSED; break;
  152.         case 0x11: key_status[KEY_NUM4] = KEY_PRESSED; break;
  153.     }
  155.     Key_StatusJudge(KEY_NUM1);
  156.     Key_StatusJudge(KEY_NUM2);
  157.     Key_StatusJudge(KEY_NUM3);
  158.     Key_StatusJudge(KEY_NUM4);
  159. }
  162. // Used for install the key press function
  163. void Key_InstallPressFunc(key_num_t key, Key_Func func)
  164. {
  165.     key_press_func[key] = func;
  166. }
  168. // Used for install the key released function
  169. void Key_InstallReleaseFunc(key_num_t key, Key_Func func)
  170. {
  171.     key_release_func[key] = func;
  172. }
  175. key_status_t Key_GetStatus(key_num_t key)
  176. {
  177.     return key_status[key];
  178. }


app_key.h

  1. /*
  2. @hehung
  3. 2023-7-8
  4. email: 1398660197@qq.com
  5. wechat: hehung95
  6. reproduced and please indicate the source @hehung
  7. */
  9. #ifndef APP_KEY_H_
  10. #define APP_KEY_H_
  12. #include "app_config.h"
  15. #define KEY_TOTAL_NUM            (4U)
  17. // function pointer
  18. typedef void (*Key_Func)(void);
  21. typedef enum
  22. {
  23.     KEY_PRESSED = 0U,
  24.     KEY_RELEASED = 1U
  25. } key_status_t;
  27. typedef enum
  28. {
  29.     KEY_NUM1 = 0U,
  30.     KEY_NUM2,
  31.     KEY_NUM3,
  32.     KEY_NUM4
  33. } key_num_t;
  37. extern void Key_Scan(void);
  38. extern key_status_t Key_GetStatus(key_num_t key);
  39. extern void Key_InstallPressFunc(key_num_t key, Key_Func func);
  41. #endif /* APP_KEY_H_ */


3.3 FreeRTOS

注册了两个任务：

- 一个是LED任务，用来控制LED4每500ms翻转一次
- 一个是按键任务，用于控制对应按键动作

当按键KEY1按下时，LED1翻转

当按键KEY2按下时，LED2翻转

当按键KEY3按下时，LED3翻转

当按键KEY4按下时，LED1，LED2，LED3都会翻转

任务Os_TaskKey中会调用Key_InstallPressFunc先注册Key1~Key4的按下函数，代码如下，但是调用Key_Scan开始按键的周期采样按断以及处理：

  1. /*
  2. @hehung
  3. 2023-7-8
  4. email: 1398660197@qq.com
  5. wechat: hehung95
  6. reproduced and please indicate the source @hehung
  7. */
  9. #include "app_freeRTOS.h"
  10. #include <FreeRTOS.h>
  11. #include <task.h>
  13. #include "app_led.h"
  14. #include "app_key.h"
  15. #include "printf.h"
  18. static void Os_TaskLed(void *pvParameters);
  19. static void Os_TaskKey(void *pvParameters);
  22. /* Initialize for OS driver */
  23. void Os_Start(void)
  24. {
  25.     // Installing the tasks
  26.     xTaskCreate(Os_TaskLed, "led_t", 256, (void*)0, 8, 0);
  27.     xTaskCreate(Os_TaskKey, "key_t", 512, (void*)0, 2, 0);
  29.     vTaskStartScheduler();
  30. }
  33. // Led control task
  34. static void Os_TaskLed(void *pvParameters)
  35. {
  36.     (void)(pvParameters);
  38.     // Initialize LEDs
  39.     Led_Init();
  41.     while(1)
  42.     {
  43.         gpio_toggle(LED4);
  45.         vTaskDelay(500);
  46.     }
  47. }
  49. void Os_TaskKey1_pressed(void)
  50. {
  51.     gpio_toggle(LED1);
  52. }
  54. void Os_TaskKey2_pressed(void)
  55. {
  56.     gpio_toggle(LED2);
  57. }
  59. void Os_TaskKey3_pressed(void)
  60. {
  61.     gpio_toggle(LED3);
  62. }
  64. void Os_TaskKey4_pressed(void)
  65. {
  66.     gpio_toggle(LED1);
  67.     gpio_toggle(LED2);
  68.     gpio_toggle(LED3);
  69. }
  71. static void Os_TaskKey(void *pvParameters)
  72. {
  73.     (void)(pvParameters);
  75.     // Installing the key press handler function
  76.     Key_InstallPressFunc(KEY_NUM1, Os_TaskKey1_pressed);
  77.     Key_InstallPressFunc(KEY_NUM2, Os_TaskKey2_pressed);
  78.     Key_InstallPressFunc(KEY_NUM3, Os_TaskKey3_pressed);
  79.     Key_InstallPressFunc(KEY_NUM4, Os_TaskKey4_pressed);
  81.     while(1)
  82.     {
  83.         Key_Scan();
  85.         vTaskDelay(10);
  86.     }
  87. }


3.4 主函数

主函数如下：

  1. int main (void)
  2. {
  3.     sys_init(LDO_1P4_LDO_1P8, VBAT_MAX_VALUE_GREATER_THAN_3V6);
  4.     //Note: This function can improve the performance of some modules, which is described in the function comments.
  5.     //Called immediately after sys_init, set in other positions, some calibration values may not take effect.
  6.     user_read_flash_value_calib();
  8.     CCLK_24M_HCLK_24M_PCLK_24M;
  10.     printf("\r\n");  // user for avoid print garbled code on the first character
  11.     printf("\r\n ==== Test project for B91 ==== \r\n");
  13.     // Install the tasks and start FreeRTOS scheduler
  14.     Os_Start();
  16.     while (1) {}
  18.     return 0;
  19. }


4 实现效果


如下演示视频，演示了4个按钮的控制功能。