Skip to content

multi button use common call interface #32

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 2 commits into
base: master
Choose a base branch
from
Open

multi button use common call interface #32

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
71c11b0
fix: drop button id func implement
lanxb Aug 22, 2022
32ed847
feat: multi button use common call interface
lanxb Aug 24, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
231 changes: 179 additions & 52 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,31 +1,37 @@
# MultiButton

## 简介

MultiButton 是一个小巧简单易用的事件驱动型按键驱动模块，可无限量扩展按键，按键事件的回调异步处理方式可以简化你的程序结构，去除冗余的按键处理硬编码，让你的按键业务逻辑更清晰。

## 使用方法

1.先申请一个按键结构

```c
struct Button button1;
```

2.初始化按键对象，绑定按键的GPIO电平读取接口**read_button_pin()** ，后一个参数设置有效触发电平

```c
button_init(&button1, read_button_pin, 0, 0);
button_init(&button1, read_button_pin, 0);
```

3.注册按键事件

```c
button_attach(&button1, SINGLE_CLICK, Callback_SINGLE_CLICK_Handler);
button_attach(&button1, DOUBLE_CLICK, Callback_DOUBLE_Click_Handler);
button_attach(&button1, SINGLE_CLICK, BTN_EVENT_Handler);
button_attach(&button1, DOUBLE_CLICK, BTN_EVENT_Handler);
...
```

4.启动按键

```c
button_start(&button1);
```

5.设置一个5ms间隔的定时器循环调用后台处理函数

```c
Expand All @@ -52,82 +58,203 @@ struct Button {
uint8_t debounce_cnt : 3;
uint8_t active_level : 1;
uint8_t button_level : 1;
uint8_t button_id;
uint8_t (*hal_button_Level)(uint8_t button_id_);
uint8_t (*hal_button_Level)(void);
BtnCallback cb[number_of_event];
struct Button* next;
};
```
这样每个按键使用单向链表相连，依次进入 button_handler(struct Button* handle) 状态机处理，所以每个按键的状态彼此独立。

这样每个按键使用单向链表相连，依次进入 button_handler(struct Button* handle) 状态机处理，所以每个按键的状态彼此独立。

## 按键事件

事件 | 说明
---|---
PRESS_DOWN | 按键按下，每次按下都触发
PRESS_UP | 按键弹起，每次松开都触发
PRESS_REPEAT | 重复按下触发，变量repeat计数连击次数
SINGLE_CLICK | 单击按键事件
DOUBLE_CLICK | 双击按键事件
LONG_PRESS_START | 达到长按时间阈值时触发一次
LONG_PRESS_HOLD | 长按期间一直触发

| 事件 | 说明 |
| ---------------- | ------------------------------------ |
| PRESS_DOWN | 按键按下，每次按下都触发 |
| PRESS_UP | 按键弹起，每次松开都触发 |
| PRESS_REPEAT | 重复按下触发，变量repeat计数连击次数 |
| SINGLE_CLICK | 单击按键事件 |
| DOUBLE_CLICK | 双击按键事件 |
| LONG_PRESS_START | 达到长按时间阈值时触发一次 |
| LONG_PRESS_HOLD | 长按期间一直触发 |

## Examples

```c
#include "button.h"
#include "multi_button.h"

unit8_t btn1_id = 0;
typedef enum {
BUTTON_ID_0,
BUTTON_ID_2,

struct Button btn1;
BUTTON_ID_MAX

uint8_t read_button_GPIO(uint8_t button_id)
} BUTTON_ID_INDEX;

struct Button btnGroup[BUTTON_ID_MAX];
uint8_t btnActiveLevel[BUTTON_ID_MAX] = {0, 0};

uint8_t read_button_level()
{
// you can share the GPIO read function with multiple Buttons
switch(button_id)
uint8_t code = 0x01;
for (size_t i = 0; i < BUTTON_ID_MAX; i++)
{
case btn1_id:
return HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin);
break;
if (get_button_current() == &btnGroup[i])
{
switch (i)
{
case BUTTON_ID_0:
code = HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin);
break;
case BUTTON_ID_2:
code = HAL_GPIO_ReadPin(B2_GPIO_Port, B2_Pin);
break;

default:
return 0;
break;
default:
break;
}
}
}
}
void BTN1_PRESS_DOWN_Handler(void* btn)
{
//do something...
return code;
}

void BTN1_PRESS_UP_Handler(void* btn)
void BTN_EVENT_Handler(void *btn)
{
//do something...
}
for (size_t i = 0; i < BUTTON_ID_MAX; i++)
{
if (((Button *)btn) == &btnGroup[i])
{
switch (((Button *)btn)->event)
{
case PRESS_DOWN:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

...
default:
break;
}
break;
case PRESS_UP:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

default:
break;
}
break;
case PRESS_REPEAT:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

default:
break;
}
break;
case SINGLE_CLICK:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

default:
break;
}
break;
case DOUBLE_CLICK:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

default:
break;
}
break;
case LONG_PRESS_START:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

default:
break;
}
break;
case LONG_PRESS_HOLD:
switch (i)
{
case BUTTON_ID_0:
// do something
break;
case BUTTON_ID_2:
// do something
break;

default:
break;
}
break;

default:
break;
}
}
}
}

int main()
{
button_init(&btn1, read_button_GPIO, 0, btn1_id);
button_attach(&btn1, PRESS_DOWN, BTN1_PRESS_DOWN_Handler);
button_attach(&btn1, PRESS_UP, BTN1_PRESS_UP_Handler);
button_attach(&btn1, PRESS_REPEAT, BTN1_PRESS_REPEAT_Handler);
button_attach(&btn1, SINGLE_CLICK, BTN1_SINGLE_Click_Handler);
button_attach(&btn1, DOUBLE_CLICK, BTN1_DOUBLE_Click_Handler);
button_attach(&btn1, LONG_PRESS_START, BTN1_LONG_PRESS_START_Handler);
button_attach(&btn2, LONG_PRESS_HOLD, BTN1_LONG_PRESS_HOLD_Handler);
button_start(&btn1);

//make the timer invoking the button_ticks() interval 5ms.
//This function is implemented by yourself.
for (size_t i = 0; i < BUTTON_ID_MAX; i++)
{
button_init(&btnGroup[i], read_button_level, btnActiveLevel[i]);

button_attach(&btnGroup[i], PRESS_DOWN, BTN_EVENT_Handler);
button_attach(&btnGroup[i], PRESS_UP, BTN_EVENT_Handler);
button_attach(&btnGroup[i], PRESS_REPEAT, BTN_EVENT_Handler);
button_attach(&btnGroup[i], SINGLE_CLICK, BTN_EVENT_Handler);
button_attach(&btnGroup[i], DOUBLE_CLICK, BTN_EVENT_Handler);
button_attach(&btnGroup[i], LONG_PRESS_START, BTN_EVENT_Handler);
button_attach(&btnGroup[i], LONG_PRESS_HOLD, BTN_EVENT_Handler);

button_start(&btnGroup[i]);
}

// make the timer invoking the button_ticks() interval 5ms.
// This function is implemented by yourself.
__timer_start(button_ticks, 0, 5);

while(1)
{}
while (1)
{
}
}
```


Loading