2024-01-23 20:05:30 +08:00
|
|
|
#ifndef __KEY_PRIVATE_FSM_H_
|
|
|
|
#define __KEY_PRIVATE_FSM_H_
|
|
|
|
|
|
|
|
#include "FSM_protected.h"
|
|
|
|
#include "keyFSM.h"
|
|
|
|
#include <stdio.h>
|
2024-01-23 22:45:29 +08:00
|
|
|
#include <assert.h>
|
2024-01-23 20:05:30 +08:00
|
|
|
|
2024-04-24 14:25:31 +08:00
|
|
|
extern KeyIn keystat;
|
|
|
|
|
|
|
|
|
2024-01-23 20:05:30 +08:00
|
|
|
/*
|
|
|
|
继承基类
|
|
|
|
*/
|
|
|
|
typedef struct _KeyFSM
|
|
|
|
{
|
|
|
|
// 继承父类
|
|
|
|
FSM base;
|
|
|
|
}KeyFSM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
状态和对应的 action, exit, during 函数
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum _State
|
|
|
|
{
|
2024-01-23 22:45:29 +08:00
|
|
|
Idle_State,
|
|
|
|
Waiting,
|
|
|
|
DownDebouncing,
|
|
|
|
Downing,
|
|
|
|
Holding,
|
2024-04-20 21:16:26 +08:00
|
|
|
HoldUpDebouncing,
|
2024-01-23 22:45:29 +08:00
|
|
|
UpDebouncing,
|
2024-01-24 01:26:37 +08:00
|
|
|
MultiDownWaiting,
|
|
|
|
MultiDowning,
|
2024-01-29 14:04:24 +08:00
|
|
|
MultiDownDebouncing,
|
2024-01-23 20:05:30 +08:00
|
|
|
|
|
|
|
Count_State,
|
|
|
|
} State;
|
2024-01-23 22:45:29 +08:00
|
|
|
#define DEFAULT_STATE Waiting
|
2024-01-23 20:05:30 +08:00
|
|
|
|
2024-04-20 21:16:26 +08:00
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/* 下一个状态选择函数 */
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static State selectNextStateFcn(Waiting)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
|
|
|
|
if(data->external.in == Down){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键按下 ");
|
|
|
|
return DownDebouncing;
|
|
|
|
}
|
|
|
|
return Idle_State;
|
|
|
|
}
|
|
|
|
|
|
|
|
static State selectNextStateFcn(DownDebouncing)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == pUp){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键松开 ");
|
|
|
|
return Waiting;
|
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
|
|
|
|
else if(data->internal.countDelay == 5){
|
2024-04-20 21:16:26 +08:00
|
|
|
return Downing;
|
|
|
|
}
|
|
|
|
return Idle_State;
|
|
|
|
}
|
|
|
|
|
|
|
|
static State selectNextStateFcn(Downing)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == pUp){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键松开 ");
|
|
|
|
return UpDebouncing;
|
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
else if(data->internal.countDelay == 10){
|
2024-04-20 21:16:26 +08:00
|
|
|
return Holding;
|
|
|
|
}
|
|
|
|
return Idle_State;
|
|
|
|
}
|
2024-01-23 22:45:29 +08:00
|
|
|
|
2024-04-20 21:16:26 +08:00
|
|
|
static State selectNextStateFcn(Holding)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == pUp){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键松开 ");
|
|
|
|
return HoldUpDebouncing;
|
|
|
|
}
|
|
|
|
return Idle_State;
|
|
|
|
}
|
2024-04-20 20:05:33 +08:00
|
|
|
|
2024-04-20 21:16:26 +08:00
|
|
|
static State selectNextStateFcn(HoldUpDebouncing)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == Down){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键按下 ");
|
|
|
|
return Holding;
|
2024-04-20 20:05:33 +08:00
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
else if(data->internal.countDelay == 5){
|
2024-04-20 21:16:26 +08:00
|
|
|
return Waiting;
|
2024-04-20 20:05:33 +08:00
|
|
|
}
|
2024-04-20 21:16:26 +08:00
|
|
|
return Idle_State;
|
|
|
|
}
|
|
|
|
|
|
|
|
static State selectNextStateFcn(UpDebouncing)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == Down){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键按下 ");
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->internal.countMultiDown){
|
2024-04-20 21:16:26 +08:00
|
|
|
return MultiDowning;
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
return Downing;
|
|
|
|
}
|
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
else if(data->internal.countDelay == 5){
|
2024-04-20 21:16:26 +08:00
|
|
|
return MultiDownWaiting;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Idle_State;
|
|
|
|
}
|
|
|
|
|
|
|
|
static State selectNextStateFcn(MultiDownWaiting)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == Down){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键按下 ");
|
|
|
|
return MultiDownDebouncing;
|
2024-04-20 20:05:33 +08:00
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
else if(data->internal.countDelay == 5){
|
2024-04-20 21:16:26 +08:00
|
|
|
return Waiting;
|
2024-04-20 20:05:33 +08:00
|
|
|
}
|
2024-04-20 21:16:26 +08:00
|
|
|
return Idle_State;
|
2024-04-20 20:05:33 +08:00
|
|
|
}
|
|
|
|
|
2024-04-20 21:16:26 +08:00
|
|
|
static State selectNextStateFcn(MultiDowning)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == pUp){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键松开 ");
|
|
|
|
return UpDebouncing;
|
|
|
|
}
|
|
|
|
return Idle_State;
|
|
|
|
}
|
|
|
|
|
|
|
|
static State selectNextStateFcn(MultiDownDebouncing)(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
if(data->external.in == pUp){
|
2024-04-20 21:16:26 +08:00
|
|
|
FSM_LOG(" 物理按键松开 ");
|
|
|
|
return MultiDownWaiting;
|
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
else if(data->internal.countDelay == 5){
|
2024-04-20 21:16:26 +08:00
|
|
|
return MultiDowning;
|
|
|
|
}
|
|
|
|
return Idle_State;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/* 对应的 action, exit, during 函数 */
|
|
|
|
/* -------------------------------------------------------------------------- */
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(enter, Waiting)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Idle;
|
|
|
|
data->internal.countDelay = 0;
|
|
|
|
data->internal.countMultiDown = 0;
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
2024-01-23 22:45:29 +08:00
|
|
|
|
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
|
2024-01-23 20:05:30 +08:00
|
|
|
{
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay++;
|
2024-01-29 11:12:32 +08:00
|
|
|
FSM_LOG(" during开启消抖 ");
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
2024-01-24 01:26:37 +08:00
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(during, Downing)(KeyFSMData* data)
|
2024-01-23 20:05:30 +08:00
|
|
|
{
|
2024-01-29 20:32:07 +08:00
|
|
|
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay++;
|
|
|
|
data->internal.out = Idle;
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
2024-01-23 22:45:29 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
|
|
|
|
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay++;
|
2024-01-29 11:12:32 +08:00
|
|
|
FSM_LOG(" during松开消抖 ");
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
2024-01-23 22:45:29 +08:00
|
|
|
|
2024-01-24 01:26:37 +08:00
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(during, Holding)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Idle;
|
|
|
|
data->internal.countDelay++;
|
|
|
|
if(data->internal.countDelay == 2){
|
|
|
|
data->internal.out = Hold;
|
|
|
|
data->internal.countDelay = 0;
|
2024-01-23 23:28:15 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(exit, Holding)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Idle;
|
2024-01-24 01:26:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay++;
|
2024-01-29 11:12:32 +08:00
|
|
|
FSM_LOG(" during多击等待 ");
|
2024-01-24 01:26:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2024-01-23 23:28:15 +08:00
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
|
2024-01-28 23:43:13 +08:00
|
|
|
{
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay++;
|
2024-01-28 23:43:13 +08:00
|
|
|
}
|
2024-01-29 14:04:24 +08:00
|
|
|
|
2024-01-29 20:32:07 +08:00
|
|
|
|
|
|
|
static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
|
2024-01-29 14:04:24 +08:00
|
|
|
{
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay++;
|
2024-01-29 14:04:24 +08:00
|
|
|
}
|
2024-01-29 20:32:07 +08:00
|
|
|
|
2024-01-28 23:43:13 +08:00
|
|
|
|
2024-04-20 21:16:26 +08:00
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/* 转移函数 */
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
void transitionGeneralAction(KeyFSMData *data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countDelay = 0;
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
|
|
|
|
2024-04-23 14:53:47 +08:00
|
|
|
static State transitionHandler(DownDebouncing, Downing)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Down;
|
2024-04-20 21:16:26 +08:00
|
|
|
}
|
2024-01-23 22:45:29 +08:00
|
|
|
|
2024-01-23 20:05:30 +08:00
|
|
|
|
2024-04-23 14:53:47 +08:00
|
|
|
static State transitionHandler(UpDebouncing, MultiDownWaiting)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Idle;
|
|
|
|
data->internal.countMultiDown++;
|
2024-01-30 19:38:48 +08:00
|
|
|
}
|
|
|
|
|
2024-04-23 14:53:47 +08:00
|
|
|
static State transitionHandler(MultiDownDebouncing, MultiDowning)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
switch (data->internal.countMultiDown + 1)
|
2024-01-23 22:45:29 +08:00
|
|
|
{
|
2024-04-20 21:16:26 +08:00
|
|
|
case 2:
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Down_2times;
|
2024-04-20 21:16:26 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Down_3times;
|
2024-04-20 21:16:26 +08:00
|
|
|
break;
|
|
|
|
|
2024-01-23 22:45:29 +08:00
|
|
|
default:
|
2024-04-20 21:16:26 +08:00
|
|
|
printf("reach MultiDown Limit!\n");
|
|
|
|
break;
|
2024-01-23 22:45:29 +08:00
|
|
|
}
|
2024-04-24 14:25:31 +08:00
|
|
|
FSM_LOG(" 多击%d ", data->internal.countMultiDown+1);
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
|
|
|
|
2024-04-23 14:32:23 +08:00
|
|
|
|
2024-04-23 14:53:47 +08:00
|
|
|
static State transitionHandler(Downing, Holding)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.out = Hold;
|
2024-01-23 23:28:15 +08:00
|
|
|
}
|
|
|
|
|
2024-04-23 14:32:23 +08:00
|
|
|
static State transitionHandler(MultiDownWaiting, Waiting)(KeyFSMData* data){
|
2024-04-24 14:25:31 +08:00
|
|
|
data->internal.countMultiDown = 0;
|
2024-04-23 14:32:23 +08:00
|
|
|
}
|
2024-01-23 23:28:15 +08:00
|
|
|
|
2024-01-24 10:20:05 +08:00
|
|
|
|
2024-01-23 20:05:30 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
用户自定义事件选择逻辑—————————————————begin
|
|
|
|
*/
|
|
|
|
const static char *stateStr[] = {
|
|
|
|
"Idle",
|
2024-01-23 22:45:29 +08:00
|
|
|
"Waiting",
|
|
|
|
"DownDebouncing",
|
|
|
|
"Downing",
|
|
|
|
"Holding",
|
2024-04-23 14:32:23 +08:00
|
|
|
"HoldUpDebouncing",
|
2024-01-23 22:45:29 +08:00
|
|
|
"UpDebouncing",
|
2024-01-24 01:26:37 +08:00
|
|
|
"MultiDownWaiting",
|
|
|
|
"MultiDowning",
|
2024-01-29 14:04:24 +08:00
|
|
|
"MultiDownDebouncing",
|
2024-01-23 20:05:30 +08:00
|
|
|
};
|
2024-04-20 21:16:26 +08:00
|
|
|
|
2024-01-23 20:05:30 +08:00
|
|
|
static void printFSM(KeyFSM* pFSM){
|
2024-04-23 19:38:43 +08:00
|
|
|
KeyFSMData* data = pFSM->base.data;
|
2024-01-29 14:04:24 +08:00
|
|
|
FSM_LOG("KeyFSM: ");
|
2024-04-24 14:25:31 +08:00
|
|
|
FSM_LOG("%d, 当前状态:%s, \t上一个下次事件:%s \t转移:", data->internal.countDelay, stateStr[getFSMCurState((FSM *)pFSM)], stateStr[getFSMNextState((FSM *)pFSM)]);
|
2024-01-23 20:05:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|