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

Compare commits

base: Klagarge:262b89fe45b08c8b45184de2992a864d1b76cb76
Branches Tags
Klagarge:master
Klagarge:comments
Klagarge:render
..
compare: Klagarge:0d07b98cfdf48850727ef10361cd711a83f9dd8a
Branches Tags
Klagarge:comments
Klagarge:master
Klagarge:render

No commits in common. "262b89fe45b08c8b45184de2992a864d1b76cb76" and "0d07b98cfdf48850727ef10361cd711a83f9dd8a" have entirely different histories.
262b89fe45 ... 0d07b98cfd

11 changed files with 202 additions and 116 deletions
Show Stats Expand all files Collapse all files

68
src/app/buttoneventslogger.cpp
View File

@ -9,13 +9,8 @@
#include "trace/trace.h"
#include "ButtonEvent.h"
ButtonEventsLogger::ButtonEventsLogger()
: stWait(this) {
stInitial.addInitialTransition(&stWait);
stWait.addTransition(event::evButtonShortPressed, &stWait);
stWait.addTransition(event::evButtonLongPressed, &stWait);
stWait.registerOnEntry((XFState::callbackEv)&ButtonEventsLogger::logOnTrace);
ButtonEventsLogger::ButtonEventsLogger() {
curentState_ = state::initial;
}
void ButtonEventsLogger::onButtonShortPressed(ButtonIndex buttonIndex) {
@ -26,13 +21,62 @@ void ButtonEventsLogger::onButtonLongPressed(ButtonIndex buttonIndex) {
GEN(ButtonEvent(event::evButtonLongPressed, this, buttonIndex));
}
void ButtonEventsLogger::logOnTrace(const XFEvent* ev) {
ButtonEvent* buttonEvent = (ButtonEvent*)ev;
int evid = buttonEvent->getId();
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", buttonEvent->getButtonId());
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", buttonEvent->getButtonId());
Trace::out("ButtonEventLogger: Button %d long pressed", ev->getButtonId());
curentState_ = state::waitButtonPressed;
changeXFState = true;
eventStatus = XFEventStatus::Consumed;
}
break;
}
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;
}
return eventStatus;
}

12
src/app/buttoneventslogger.h
View File

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

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

@ -16,12 +16,12 @@ ButtonEventsHandler::ButtonEventsHandler()
observer_[i] = nullptr;
}
stInitial.addInitialTransition(&stRun);
stInitial.setNextState(&stRun);
stRun.registerOnEntry((XFState::callback)&ButtonEventsHandler::startButtonSM);
}
void ButtonEventsHandler::startButtonSM() {
void ButtonEventsHandler::startButtonSM(const XFEvent* ev) {
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();
void startButtonSM(const XFEvent* ev);
XFState stRun;

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

@ -8,27 +8,10 @@
#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()),
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);
: buttonIndex_(getNbInstance()) {
currentState_ = state::initial;
}
uint8_t ButtonStateSm::getNbInstance(){
@ -43,14 +26,102 @@ void ButtonStateSm::genButtonReleased() {
GEN(XFEvent(XFEvent::Event, event::evButtonReleased, this));
}
void ButtonStateSm::notifyShortPress() {
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;
void ButtonStateSm::notifyLongPress() {
case state::buttonLongPressed:
ButtonEventsHandler::getInstance()->notifyButtonLongPressed(buttonIndex_);
break;
}
void ButtonStateSm::genNullTransition() {
GEN(XFEvent(XFEvent::Event, event::evReturn, this));
}
return eventStatus;
}

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

@ -18,23 +18,26 @@ public:
void genButtonReleased();
protected:
void notifyShortPress();
void notifyLongPress();
void genNullTransition();
XFEventStatus processEvent();
typedef enum {
evButtonPressed = 10,
evButtonPressed,
evButtonReleased,
evTimeout,
evReturn
evTimeout
} event;
const uint8_t buttonIndex_;
typedef enum {
initial,
waitButtonPressed,
buttonPressed,
buttonShortPressed,
buttonLongPressed
} state;
XFState stWaitButtonPressed;
XFState stButtonPressed;
XFState stButtonShortPressed;
XFState stButtonLongPressed;
state currentState_;
state oldState_;
bool changeState_;
const uint8_t buttonIndex_;
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.addInitialTransition(&stCheckButtons);
stCheckButtons.addTransition(event::evButtonIrq, &stDebounce);
stInitial.setNextState(&stCheckButtons);
stCheckButtons.setNextState(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() {
void ButtonsController::fctCheckButtons(const XFEvent* ev) {
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,7 +30,8 @@ protected:
bool newState[4];
bool buttonState[4];
void fctCheckButtons();
void fctCheckButtons(const XFEvent* ev);
void fctScheduleTimeout(const XFEvent* ev);
XFState stCheckButtons;
XFState stDebounce;

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

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

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

@ -24,20 +24,17 @@ public:
XFState(XFBehavior* behavior);
~XFState() = default;
inline void addTransition(const int evid, XFState* state) { addTransition(XFEvent::XFEventType::Event, evid, 0, state); };
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 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 setTimeout(int time, XFState* nextState) { setNextState(XFEvent::Timeout, time, XFEvent::XFEventType::Timeout, nextState); };
typedef void (XFBehavior::*callback)(const XFEvent* ev);
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:
void addTransition(XFEvent::XFEventType type, const int evid, const int time, XFState* state);
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);
XFEventStatus onState(const XFEvent* ev);
void onEntry(const XFEvent* ev);
@ -53,20 +50,9 @@ 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:
XFInitialState stInitial;
XFState stInitial;
XFState* curentXFState_ = &stInitial;
XFState* oldXFState_ = &stInitial;
bool changeXFState = false;