Klagarge/ButtonManager
Archived
1
0
Fork 0
Code Issues Pull Requests Releases 1 Activity

Merge branch 'enhancement'

Browse Source
This commit is contained in:
Rémi Heredero 2023-11-27 17:09:53 +01:00
commit 262b89fe45
11 changed files with 118 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/app/buttoneventslogger.cpp
View File

@ -9,8 +9,13 @@
#include "trace/trace.h"
#include "ButtonEvent.h"
ButtonEventsLogger::ButtonEventsLogger() {
curentState_ = state::initial;
ButtonEventsLogger::ButtonEventsLogger()
: stWait(this) {
stInitial.addInitialTransition(&stWait);
stWait.addTransition(event::evButtonShortPressed, &stWait);
stWait.addTransition(event::evButtonLongPressed, &stWait);
stWait.registerOnEntry((XFState::callbackEv)&ButtonEventsLogger::logOnTrace);
}
void ButtonEventsLogger::onButtonShortPressed(ButtonIndex buttonIndex) {
@ -21,62 +26,13 @@ void ButtonEventsLogger::onButtonLongPressed(ButtonIndex buttonIndex) {
GEN(ButtonEvent(event::evButtonLongPressed, this, buttonIndex));
}
XFEventStatus ButtonEventsLogger::processEvent() {
eEventStatus eventStatus = XFEventStatus::NotConsumed;
ButtonEvent* ev = (ButtonEvent*)getCurrentEvent();
XFEvent::XFEventType evType = ev->getEventType();
int evid = ev->getId();
oldState_ = curentState_;
changeXFState = false;
switch (curentState_) { //on state
case state::initial:
if(evType == XFEvent::Initial) {
curentState_ = state::waitButtonPressed;
changeXFState = true;
eventStatus = XFEventStatus::Consumed;
}
break;
case state::waitButtonPressed:
if(evid == event::evButtonShortPressed){
Trace::out("ButtonEventLogger: Button %d short pressed", ev->getButtonId());
curentState_ = state::waitButtonPressed;
changeXFState = true;
eventStatus = XFEventStatus::Consumed;
}
if(evid == event::evButtonLongPressed){
Trace::out("ButtonEventLogger: Button %d long pressed", ev->getButtonId());
curentState_ = state::waitButtonPressed;
changeXFState = true;
eventStatus = XFEventStatus::Consumed;
}
break;
void ButtonEventsLogger::logOnTrace(const XFEvent* ev) {
ButtonEvent* buttonEvent = (ButtonEvent*)ev;
int evid = buttonEvent->getId();
if(evid == event::evButtonShortPressed){
Trace::out("ButtonEventLogger: Button %d short pressed", buttonEvent->getButtonId());
}
if(changeXFState) {
switch (oldState_) { // onExit
case state::initial:
break;
case state::waitButtonPressed:
break;
}
switch (curentState_) { // onEntry
case state::initial:
break;
case state::waitButtonPressed:
break;
}
changeXFState = false;
if(evid == event::evButtonLongPressed){
Trace::out("ButtonEventLogger: Button %d long pressed", buttonEvent->getButtonId());
}
return eventStatus;
}

12
src/app/buttoneventslogger.h
View File

@ -21,20 +21,14 @@ public:
protected:
XFEventStatus processEvent() override;
void logOnTrace(const XFEvent* ev);
typedef enum {
evButtonShortPressed = 1,
evButtonShortPressed = 10,
evButtonLongPressed
} event;
typedef enum {
initial,
waitButtonPressed
} state;
state curentState_;
state oldState_;
XFState stWait;
};

4
src/mdw/button/ButtonEventsHandler.cpp
View File

@ -16,12 +16,12 @@ ButtonEventsHandler::ButtonEventsHandler()
observer_[i] = nullptr;
}
stInitial.setNextState(&stRun);
stInitial.addInitialTransition(&stRun);
stRun.registerOnEntry((XFState::callback)&ButtonEventsHandler::startButtonSM);
}
void ButtonEventsHandler::startButtonSM(const XFEvent* ev) {
void ButtonEventsHandler::startButtonSM() {
buttonStateSm_[0].startBehavior();
buttonStateSm_[1].startBehavior();
buttonStateSm_[2].startBehavior();

2
src/mdw/button/ButtonEventsHandler.h
View File

@ -31,7 +31,7 @@ public:
protected:
ButtonEventsHandler();
void startButtonSM(const XFEvent* ev);
void startButtonSM();
XFState stRun;

131
src/mdw/button/ButtonStateSm.cpp
View File

@ -8,10 +8,27 @@
#include <button/ButtonStateSm.h>
#include "mdw/button/ButtonEventsHandler.h"
//TODO start State Machine. For that, turn ButtonEventsHandler to a State Machine (Initial, run)
ButtonStateSm::ButtonStateSm()
: buttonIndex_(getNbInstance()) {
currentState_ = state::initial;
: buttonIndex_(getNbInstance()),
stWaitButtonPressed(this),
stButtonPressed(this),
stButtonShortPressed(this),
stButtonLongPressed(this) {
stInitial.addInitialTransition(&stWaitButtonPressed);
stWaitButtonPressed.addTransition(event::evButtonPressed, &stButtonPressed);
// TODO bug if setTimeout is used before addTransition !!!
stButtonPressed.addTransition(event::evButtonReleased, &stButtonShortPressed);
stButtonPressed.setTimeout(1000, &stButtonLongPressed);
stButtonPressed.registerOnExit((XFState::callback)&ButtonStateSm::genNullTransition);
stButtonShortPressed.registerOnEntry((XFState::callback)&ButtonStateSm::notifyShortPress);
stButtonShortPressed.addTransition(event::evReturn, &stWaitButtonPressed);
stButtonLongPressed.registerOnEntry((XFState::callback)&ButtonStateSm::notifyLongPress);
stButtonLongPressed.addTransition(event::evReturn, &stWaitButtonPressed);
}
uint8_t ButtonStateSm::getNbInstance(){
@ -26,102 +43,14 @@ void ButtonStateSm::genButtonReleased() {
GEN(XFEvent(XFEvent::Event, event::evButtonReleased, this));
}
XFEventStatus ButtonStateSm::processEvent() {
eEventStatus eventStatus = XFEventStatus::Unknown;
const XFEvent* ev = getCurrentEvent();
XFEvent::XFEventType evType = ev->getEventType();
int evid = ev->getId();
oldState_ = currentState_;
changeState_ = false;
switch (currentState_) {
case state::initial:
if(evType == XFEvent::Initial) {
currentState_ = state::waitButtonPressed;
changeState_ = true;
eventStatus = XFEventStatus::Consumed;
}
break;
case state::waitButtonPressed:
if(evid == event::evButtonPressed) {
currentState_ = state::buttonPressed;
changeState_ = true;
eventStatus = XFEventStatus::Consumed;
scheduleTimeout(event::evTimeout, 1000);
}
break;
case state::buttonPressed:
if(evid == event::evButtonReleased) {
currentState_ = state::buttonShortPressed;
changeState_ = true;
eventStatus = XFEventStatus::Consumed;
unscheduleTimeout(event::evTimeout);
}
if(evid == event::evTimeout) {
currentState_ = state::buttonLongPressed;
changeState_ = true;
eventStatus = XFEventStatus::Consumed;
}
GEN(XFNullTransition(this));
break;
case state::buttonShortPressed:
if(evType == XFEvent::XFEventType::NullTransition) {
currentState_ = state::waitButtonPressed;
changeState_ = true;
eventStatus = XFEventStatus::Consumed;
}
break;
case state::buttonLongPressed:
if(evType == XFEvent::XFEventType::NullTransition) {
currentState_ = state::waitButtonPressed;
changeState_ = true;
eventStatus = XFEventStatus::Consumed;
}
break;
}
if(changeState_) {
switch (oldState_) { // onExit
case state::initial:
break;
case state::waitButtonPressed:
break;
case state::buttonPressed:
break;
case state::buttonShortPressed:
break;
case state::buttonLongPressed:
break;
}
switch (currentState_) {
case state::initial:
break;
case state::waitButtonPressed:
break;
case state::buttonPressed:
break;
case state::buttonShortPressed:
ButtonEventsHandler::getInstance()->notifyButtonShortPressed(buttonIndex_);
break;
case state::buttonLongPressed:
ButtonEventsHandler::getInstance()->notifyButtonLongPressed(buttonIndex_);
break;
}
}
return eventStatus;
void ButtonStateSm::notifyShortPress() {
ButtonEventsHandler::getInstance()->notifyButtonShortPressed(buttonIndex_);
}
void ButtonStateSm::notifyLongPress() {
ButtonEventsHandler::getInstance()->notifyButtonLongPressed(buttonIndex_);
}
void ButtonStateSm::genNullTransition() {
GEN(XFEvent(XFEvent::Event, event::evReturn, this));
}

25
src/mdw/button/ButtonStateSm.h
View File

@ -18,27 +18,24 @@ public:
void genButtonReleased();
protected:
XFEventStatus processEvent();
void notifyShortPress();
void notifyLongPress();
void genNullTransition();
typedef enum {
evButtonPressed,
evButtonPressed = 10,
evButtonReleased,
evTimeout
evTimeout,
evReturn
} event;
typedef enum {
initial,
waitButtonPressed,
buttonPressed,
buttonShortPressed,
buttonLongPressed
} state;
state currentState_;
state oldState_;
bool changeState_;
const uint8_t buttonIndex_;
XFState stWaitButtonPressed;
XFState stButtonPressed;
XFState stButtonShortPressed;
XFState stButtonLongPressed;
private:
static uint8_t getNbInstance();

6
src/platform/f7-disco-gcc/board/ButtonsController.cpp
View File

@ -16,8 +16,8 @@ ButtonsController::ButtonsController()
cbProvider = nullptr;
cbMethod = nullptr;
stInitial.setNextState(&stCheckButtons);
stCheckButtons.setNextState(event::evButtonIrq, &stDebounce);
stInitial.addInitialTransition(&stCheckButtons);
stCheckButtons.addTransition(event::evButtonIrq, &stDebounce);
stCheckButtons.registerOnEntry((XFState::callback)&ButtonsController::fctCheckButtons);
stDebounce.setTimeout(20, &stCheckButtons);
@ -45,7 +45,7 @@ bool ButtonsController::registerCallback(
return true;
}
void ButtonsController::fctCheckButtons(const XFEvent* ev) {
void ButtonsController::fctCheckButtons() {
if(cbProvider != nullptr) {
newState[0] = HAL_GPIO_ReadPin(BUTTON0_GPIO_Port, BUTTON0_Pin);

3
src/platform/f7-disco-gcc/board/ButtonsController.h
View File

@ -30,8 +30,7 @@ protected:
bool newState[4];
bool buttonState[4];
void fctCheckButtons(const XFEvent* ev);
void fctScheduleTimeout(const XFEvent* ev);
void fctCheckButtons();
XFState stCheckButtons;
XFState stDebounce;

39
src/xf/core/XFState.cpp
View File

@ -14,9 +14,15 @@
XFState::XFState(XFBehavior* behavior)
: pBehavior(behavior) {
assert(behavior != nullptr);
cbState_ = nullptr;
cbEntry_ = nullptr;
cbExit_ = nullptr;
cbEvState_ = nullptr;
cbEvEntry_ = nullptr;
cbEvExit_ = nullptr;
}
void XFState::setNextState(const int evid, const int time, XFEvent::XFEventType type, XFState* state) {
void XFState::addTransition(XFEvent::XFEventType type, const int evid, const int time, XFState* state) {
assert(state != nullptr);
transition t;
t.evid = evid;
@ -28,11 +34,14 @@ void XFState::setNextState(const int evid, const int time, XFEvent::XFEventType
XFEventStatus XFState::onState(const XFEvent* ev) {
assert(ev != nullptr);
assert(pBehavior != nullptr);
if(cbState_ != nullptr) {
(pBehavior->*cbState_)();
}
if(cbEvState_ != nullptr) {
(pBehavior->*cbEvState_)(ev);
}
for(transition t : transitions_) {
assert(t.nextState != nullptr);
if(t.evType == XFEvent::XFEventType::Initial){
pBehavior->curentXFState_ = t.nextState;
@ -59,11 +68,14 @@ XFEventStatus XFState::onState(const XFEvent* ev) {
void XFState::onEntry(const XFEvent* ev) {
if(cbEntry_ != nullptr) {
(pBehavior->*cbEntry_)(ev);
(pBehavior->*cbEntry_)();
}
if(cbEvEntry_ != nullptr) {
(pBehavior->*cbEvEntry_)(ev);
}
for(transition t : transitions_) {
assert(t.nextState != nullptr);
if(t.evType == XFEvent::XFEventType::Timeout) {
pBehavior->scheduleTimeout(XFEvent::Timeout, t.time);
@ -73,6 +85,19 @@ void XFState::onEntry(const XFEvent* ev) {
}
void XFState::onExit(const XFEvent* ev) {
if(cbExit_ != nullptr) {
(pBehavior->*cbExit_)(ev);
(pBehavior->*cbExit_)();
}
if(cbEvExit_ != nullptr) {
(pBehavior->*cbEvExit_)(ev);
}
for(transition t: transitions_) {
if(t.evType == XFEvent::XFEventType::Timeout) {
if(ev->getEventType() != XFEvent::XFEventType::Timeout) {
pBehavior->unscheduleTimeout(XFEvent::Timeout);
}
}
}
}

26
src/xf/include/xf/XFState.h
View File

@ -24,17 +24,20 @@ public:
XFState(XFBehavior* behavior);
~XFState() = default;
inline void setNextState(XFState* state) { setNextState(XFEvent::Initial, XFEvent::XFEventType::Initial, state); };
inline void setNextState(const int evid, XFState* state) { setNextState(evid, XFEvent::XFEventType::Event, state); };
inline void addTransition(const int evid, XFState* state) { addTransition(XFEvent::XFEventType::Event, evid, 0, state); };
inline void setTimeout(int time, XFState* nextState) { setNextState(XFEvent::Timeout, time, XFEvent::XFEventType::Timeout, nextState); };
typedef void (XFBehavior::*callback)(const XFEvent* ev);
inline void setTimeout(int time, XFState* nextState) { addTransition(XFEvent::XFEventType::Timeout, XFEvent::Timeout, time, nextState); };
typedef void (XFBehavior::*callback)();
typedef void (XFBehavior::*callbackEv)(const XFEvent* ev);
//inline void registerOnState(callback cbState) { cbState_ = cbState; };
inline void registerOnEntry(callback cbEntry) { cbEntry_ = cbEntry; };
inline void registerOnExit(callback cbExit) { cbExit_ = cbExit; };
//inline void registerOnState(callbackEv cbState) { cbEvState_ = cbState; };
inline void registerOnEntry(callbackEv cbEntry) { cbEvEntry_ = cbEntry; };
inline void registerOnExit(callbackEv cbExit) { cbEvExit_ = cbExit; };
protected:
inline void setNextState(const int evid, XFEvent::XFEventType type, XFState* state) {setNextState(evid, 0, type, state); };
void setNextState(const int evid, const int time, XFEvent::XFEventType type, XFState* state);
void addTransition(XFEvent::XFEventType type, const int evid, const int time, XFState* state);
XFEventStatus onState(const XFEvent* ev);
void onEntry(const XFEvent* ev);
@ -50,9 +53,20 @@ protected:
} transition;
std::list<transition> transitions_;
callback cbState_;
callback cbEntry_;
callback cbExit_;
callbackEv cbEvState_;
callbackEv cbEvEntry_;
callbackEv cbEvExit_;
};
class XFInitialState : public XFState {
public:
inline XFInitialState(XFBehavior* behavior) : XFState(behavior) {};
~XFInitialState() = default;
inline void addInitialTransition(XFState* state) { addTransition(XFEvent::XFEventType::Initial, XFEvent::Initial, 0, state); };
};
#endif /* XFSTATE_H_ */

2
src/xf/include/xf/behavior.h
View File

@ -100,7 +100,7 @@ protected:
const XFEvent * pCurrentEvent_; ///< Reference to actually processed event.
protected:
XFState stInitial;
XFInitialState stInitial;
XFState* curentXFState_ = &stInitial;
XFState* oldXFState_ = &stInitial;
bool changeXFState = false;