Klagarge/XFT
Archived
Template
1
0
Fork 0
Code Issues Releases 1 Activity

add files from blinker project

Browse Source
This commit is contained in:
Rémi Heredero
2023-07-11 15:43:00 +02:00
parent dc6a7f8799
commit c026d276a5
11 changed files with 1002 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
src/middleware/blinker.c Normal file
View File

@@ -0,0 +1,155 @@
/**
* @author R<>mi Heredero (remi@heredero.ch)
* @version. 1.0.0
* @date 2023-06-15
*/
#include "blinker.h"
void BLINKER_init(BLINKER* me) {
me->state = STBL_INIT;
me->tON = 500;
me->tOFF = 500;
me->nBlink = 3;
me->nBlinkIsOn = false;
me->remainBlinks = 3;
me->turnOn.fCallBack = NULL;
me->turnOff.fCallBack = NULL;
}
blinkerCallBack BLINKER_defineCallBack(fBlinkerCallBack f, void* param) {
blinkerCallBack c;
c.fCallBack = f;
c.param = param;
return c;
}
void BLINKER_starBehaviour(BLINKER* me) {
POST(me, &BLINKER_processEvent, evBLinit, 0, 0);
}
void BLINKER_setTurnOn(BLINKER* me, blinkerCallBack callBack) {
me->turnOn = callBack;
}
void BLINKER_setTurnOff(BLINKER* me, blinkerCallBack callBack) {
me->turnOff = callBack;
}
void BLINKER_setFinished(BLINKER* me, blinkerCallBack callBack){
me->finished = callBack;
}
void BLINKER_defineNblink(BLINKER* me, uint8_t n){
me->nBlink = n;
}
void BLINKER_setTimeOn(BLINKER*me, uint16_t t) {
me->tON = t;
}
void BLINKER_setTimeOff(BLINKER*me, uint16_t t) {
me->tOFF = t;
}
void BLINKER_blinkN(BLINKER* me){
POST(me, &BLINKER_processEvent, evBLblinkN, 0, 0);
}
void BLINKER_blink(BLINKER* me){
POST(me, &BLINKER_processEvent, evBLblink, 0, 0);
}
bool BLINKER_processEvent(Event* ev) {
bool processed = false;
BLINKER* me = (BLINKER*) Event_getTarget(ev);
BLINKER_STATES oldState = me->state;
evIDT evid = Event_getId(ev);
switch(me->state) {
case STBL_INIT:
if(evid == evBLinit) {
me->state = STBL_WAIT;
}
break;
case STBL_WAIT:
me->remainBlinks = me->nBlink;
if(evid == evBLblinkN) {
me->state = STBL_ON;
me->nBlinkIsOn = true;
POST(me, &BLINKER_processEvent, evBLtimer, me->tON, 0);
}
if(evid==evBLblink) {
me->state = STBL_ON;
me->nBlinkIsOn = false;
POST(me, &BLINKER_processEvent, evBLtimer, me->tON, 0);
}
break;
case STBL_ON:
if(me->nBlinkIsOn) me->remainBlinks--;
if(evid == evBLtimer) {
me->state = STBL_OFF;
POST(me, &BLINKER_processEvent, evBLtimer, me->tOFF, 0);
}
break;
case STBL_OFF:
if(evid == evBLtimer) {
if(me->remainBlinks == 0) {
me->state = STBL_WAIT;
if(me->finished.fCallBack != NULL) me->finished.fCallBack(me->finished.param);
} else {
me->state = STBL_ON;
POST(me, &BLINKER_processEvent, evBLtimer, me->tON, 0);
}
}
break;
}
if(oldState != me->state) {
switch(me->state) { // on entry
case STBL_INIT:
break;
case STBL_WAIT:
break;
case STBL_ON:
if(me->turnOn.fCallBack != NULL) me->turnOn.fCallBack(me->turnOn.param);
break;
case STBL_OFF:
if(me->turnOff.fCallBack != NULL) me->turnOff.fCallBack(me->turnOff.param);
break;
}
processed = true;
}
return processed;
}
void BLINKER_endBlink(BLINKER* me) {
me->remainBlinks = 0;
}
void BLINKER_toggle(BLINKER* me){
switch(me->state) {
case STBL_WAIT:
BLINKER_blink(me);
break;
case STBL_OFF:
BLINKER_endBlink(me);
break;
case STBL_ON:
BLINKER_endBlink(me);
break;
}
}

135
src/middleware/blinker.h Normal file
View File

@@ -0,0 +1,135 @@
/**
* @author R<>mi Heredero (remi@heredero.ch)
* @version 1.0.0
* @date 2023-06-15
*/
#ifndef BLINKER_H
#define BLINKER_H
#include "../xf/xf.h"
typedef enum {
STBL_INIT,
STBL_WAIT,
STBL_ON,
STBL_OFF
} BLINKER_STATES;
typedef enum {
evBLinit = 200,
evBLblink,
evBLblinkN,
evBLtimer,
evEndBlink
} BLINKER_EVENTS;
typedef void (*fBlinkerCallBack)(void*);
typedef struct {
fBlinkerCallBack fCallBack;
void* param;
} blinkerCallBack;
typedef struct {
BLINKER_STATES state; // Actual state
uint16_t tON; // Time on
uint16_t tOFF; // Time off
uint8_t nBlink; // Number of blink for this blinker when start with blinkN
bool nBlinkIsOn; // If the nBlink way is enable
uint8_t remainBlinks; // Actual remain blink
blinkerCallBack turnOn; // Callback for turnOn
blinkerCallBack turnOff; // Calbback for turnOff
blinkerCallBack finished; // Callback for finish n blink
}BLINKER;
/**
* Initialize the blinker
* @param me blinker itself
*/
void BLINKER_init(BLINKER* me);
/**
* Define a callback for BLINKER
* @param f callback for BLINKER
* @param param callback paramater for ther function
* @return the callback struct
*/
blinkerCallBack BLINKER_defineCallBack(fBlinkerCallBack f, void* param);
/**
* Start state machine of the BLINKER
* @param me the blinker itself
*/
void BLINKER_starBehaviour(BLINKER* me);
/**
* Set callback event functions for turn on
* @param me the blinker itself
* @param callBack function when the blinker is on
*/
void BLINKER_setTurnOn(BLINKER* me, blinkerCallBack callBack);
/**
* Set callback event functions for turn off
* @param me the blinker itself
* @param callBack function when the blinker is off
*/
void BLINKER_setTurnOff(BLINKER* me, blinkerCallBack callBack);
/**
* Set callback event functions for when the blinker has blink n times
* @param me the blinker itseld
* @param callBack callBack function when the blinker has blink n times
*/
void BLINKER_setFinished(BLINKER* me, blinkerCallBack callBack);
/**
* define number of time the Blinker have to blink
* @param me the blinker itself
* @param n number of blink
*/
void BLINKER_defineNblink(BLINKER* me, uint8_t n);
/**
* define time to stay ON
* @param me the blinker itself
* @param t the time to stay ON
*/
void BLINKER_setTimeOn(BLINKER*me, uint16_t t);
/**
* define time to stay OFF
* @param me the blinker itself
* @param t the time to stay OFF
*/
void BLINKER_setTimeOff(BLINKER*me, uint16_t t);
/**
* Start to blink n time
* @param me the blinker itself
*/
void BLINKER_blinkN(BLINKER* me);
/**
* Start to blink indefinitely
* @param me the blinker itself
*/
void BLINKER_blink(BLINKER* me);
/**
* State machine of the BUTTON
* @param ev event to process on the state machine
*/
bool BLINKER_processEvent(Event* ev);
/**
* Stop to blink if it was indefinitely blinking
* @param me the blinker itself
*/
void BLINKER_endBlink(BLINKER* me);
void BLINKER_toggle(BLINKER* me);
#endif /* BLINKER_H */

153
src/middleware/clickHandler.c Normal file
View File

@@ -0,0 +1,153 @@
/**
* @author R<>mi Heredero (remi@heredero.ch)
* @version. 1.0.0
* @date 2023-06-15
*/
#include "clickHandler.h"
void CLICK_HANDLER_BUTTON_PRESS(CLICK_HANDLER* me){
POST(me, &CLICK_HANDLER_processEvent, evCHpbPress, 0, 0);
}
void CLICK_HANDLER_BUTTON_RELEASE(CLICK_HANDLER * me) {
POST(me, &CLICK_HANDLER_processEvent, evCHpbRelease, 0, 0);
}
void CLICK_HANDLER_init(CLICK_HANDLER* me, BUTTON* b){
me->button = b;
me->state = STCH_INIT;
me->longClick.fCallBack = NULL;
me->singleClick.fCallBack = NULL;
me->doubleClick.fCallBack = NULL;
buttonCallBack pbPressCallBack;
pbPressCallBack.fCallBack = CLICK_HANDLER_BUTTON_PRESS;
pbPressCallBack.param = me;
buttonCallBack pbReleaseCallBack;
pbReleaseCallBack.fCallBack = CLICK_HANDLER_BUTTON_RELEASE;
pbReleaseCallBack.param = me;
BUTTON_setEventFunctions(b, pbPressCallBack, pbReleaseCallBack);
}
void CLICK_HANDLER_startBehaviour(CLICK_HANDLER* me){
POST(me, &CLICK_HANDLER_processEvent, evCHinit, 0, 0);
}
clickHandlerCallBack CLICK_HANDLER_defineCallBack(fClickHandlerCallBack f, void* param) {
clickHandlerCallBack c;
c.fCallBack = f;
c.param = param;
return c;
}
void CLICK_HANDLER_setLongClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack) {
me->longClick = callBack;
}
void CLICK_HANDLER_setSingleClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack) {
me->singleClick = callBack;
}
void CLICK_HANDLER_setDoubleClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack) {
me->doubleClick = callBack;
}
bool CLICK_HANDLER_processEvent(Event* ev) {
bool processed = false;
CLICK_HANDLER* me = (CLICK_HANDLER*)Event_getTarget(ev);
CLICK_HANDLER_STATES oldState = me->state;
evIDT evid = Event_getId(ev);
switch(me->state) {
case STCH_INIT:
if(evid == evCHinit) {
me->state = STCH_WAIT;
}
break;
case STCH_WAIT:
if(evid == evCHpbPress) {
me->state = STCH_LONG_CLICK;
POST(me, &CLICK_HANDLER_processEvent, evCHtimer, CH_CLICK_TIMER, 0);
}
break;
case STCH_LONG_CLICK:
if(evid == evCHpbRelease) {
me->state = STCH_SINGLE_CLICK;
}
if(evid == evCHtimer) {
me->state = STCH_WAIT;
if(me->longClick.fCallBack != NULL) {
me->longClick.fCallBack(me->longClick.param);
}
}
break;
case STCH_SINGLE_CLICK:
if(evid == evCHpbPress) {
me->state = STCH_DOUBLE_CLICK;
}
if(evid == evCHtimer) {
me->state = STCH_WAIT;
if(me->singleClick.fCallBack != NULL) {
me->singleClick.fCallBack(me->singleClick.param);
}
}
break;
case STCH_DOUBLE_CLICK:
if(evid == evCHpbRelease){
me->state = STCH_WAIT;
if(me->doubleClick.fCallBack != NULL){
me->doubleClick.fCallBack(me->doubleClick.param);
}
}
if(evid == evCHtimer) {
me->state = STCH_WAIT;
if(me->doubleClick.fCallBack != NULL) {
me->doubleClick.fCallBack(me->doubleClick.param);
}
}
break;
}
if(oldState != me->state) {
switch(oldState) {
case STCH_INIT:
break;
case STCH_WAIT:
break;
case STCH_LONG_CLICK:
break;
case STCH_SINGLE_CLICK:
break;
case STCH_DOUBLE_CLICK:
break;
}
processed = true;
}
return processed;
}

94
src/middleware/clickHandler.h Normal file
View File

@@ -0,0 +1,94 @@
/**
* @author R<>mi Heredero (remi@heredero.ch)
* @version. 1.0.0
* @date 2023-06-15
*/
#ifndef CLICKHANDLER_H
#define CLICKHANDLER_H
#include "../xf/xf.h"
#include "../board/button.h"
#define CH_CLICK_TIMER 250
typedef enum {
STCH_INIT,
STCH_WAIT,
STCH_LONG_CLICK,
STCH_SINGLE_CLICK,
STCH_DOUBLE_CLICK
} CLICK_HANDLER_STATES;
typedef enum {
evCHinit = 100,
evCHtimer,
evCHpbPress,
evCHpbRelease
} CLICK_HANDLER_EVENTS;
typedef void (*fClickHandlerCallBack)(void*);
typedef struct {
fClickHandlerCallBack fCallBack;
void* param;
} clickHandlerCallBack;
typedef struct {
BUTTON* button; // The button connected to the clickHandler
CLICK_HANDLER_STATES state; // The actual state
clickHandlerCallBack longClick; // Callback for longClick
clickHandlerCallBack singleClick; // Callback for singleClick
clickHandlerCallBack doubleClick; // Callback for doubleClick
}CLICK_HANDLER;
/**
* Initialize the clickHandler
* @param me the clickHandler itself
* @param b the button to connect on the clickHandler
*/
void CLICK_HANDLER_init(CLICK_HANDLER* me, BUTTON* b);
/**
* Define a callback for CLICKHANDLER
* @param f callback function for CLICKHANDLER
* @param param callback parameter for the function
* @return the callback struct
*/
clickHandlerCallBack CLICK_HANDLER_defineCallBack(fClickHandlerCallBack f, void* param);
/**
* Start state machine of the CLICKHANDLER
* @param me the clickHandler itself
*/
void CLICK_HANDLER_startBehaviour(CLICK_HANDLER* me);
/**
* Set Callback eventfunction for long click
* @param me the clickHandler itself
* @param callBack callback function when the click handler have a long click
*/
void CLICK_HANDLER_setLongClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack);
/**
* Set Callback event function for single click
* @param me the clickHandler itself
* @param callBack callback function when the click handler have a single click
*/
void CLICK_HANDLER_setSingleClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack);
/**
* Set Callback evenet function for double click
* @param me the clickHandler itself
* @param callBack callback function when the click handler have a double click
*/
void CLICK_HANDLER_setDoubleClickCallback(CLICK_HANDLER* me, clickHandlerCallBack callBack);
/**
* State machine of the CLICKHANDLER
* @param ev event to process on the state machine
*/
bool CLICK_HANDLER_processEvent(Event* ev);
#endif /* CLICKHANDLER_H */