260 lines
6.2 KiB
C
260 lines
6.2 KiB
C
/**
|
|
* @author Rémi Heredero
|
|
* @version 1.0.0
|
|
* @date August 2023
|
|
* @file alive.c
|
|
*/
|
|
|
|
#include "alive.h"
|
|
|
|
void ALIVE_init(ALIVE* me){
|
|
me->state = STAL_INIT;
|
|
me->isAlive = false;
|
|
me->checker = false;
|
|
me->sender = false;
|
|
me->haveBreak = true;
|
|
me->aliveTime = 10;
|
|
me->setup.f = NULL;
|
|
me->born.f = NULL;
|
|
me->wait.f = NULL;
|
|
me->dead.f = NULL;
|
|
me->alive.f = NULL;
|
|
me->break_cb.f = NULL;
|
|
}
|
|
|
|
void ALIVE_startBehaviourChecker(ALIVE* me){
|
|
POST(me, &ALIVE_processEvent, evALinitChecker, 0, 0);
|
|
}
|
|
|
|
void ALIVE_startBehaviourSender(ALIVE* me){
|
|
POST(me, &ALIVE_processEvent, evALinitSender, 0, 0);
|
|
}
|
|
|
|
bool ALIVE_processEvent(Event* ev) {
|
|
bool processed = false;
|
|
ALIVE* me = (ALIVE*)Event_getTarget(ev);
|
|
ALIVE_STATES oldState = me->state;
|
|
evIDT evid = Event_getId(ev);
|
|
uint64_t data = Event_getData(ev);
|
|
|
|
switch (me->state) { // onState
|
|
case STAL_INIT:
|
|
if (ev->id == evALinitChecker) {
|
|
me->state = STAL_SETUP;
|
|
}
|
|
if (ev->id == evALinitSender) {
|
|
me->state = STAL_ALIVE;
|
|
ALIVE_emitPoll(me, me->aliveTime*10, 0);
|
|
}
|
|
break;
|
|
|
|
case STAL_SETUP:
|
|
if (ev->id == evALborn) {
|
|
me->state = STAL_BORN;
|
|
}
|
|
break;
|
|
|
|
case STAL_BORN:
|
|
if (ev->id == evALready) {
|
|
me->state = STAL_WAIT;
|
|
ALIVE_emitPoll(me, me->aliveTime*10, 0);
|
|
}
|
|
break;
|
|
|
|
case STAL_WAIT:
|
|
if (ev->id == evALpoll) {
|
|
|
|
if (me->aliveTime == 0) {
|
|
if (me->haveBreak){
|
|
me->state = STAL_BREAK;
|
|
}
|
|
} else if (me->isAlive){
|
|
me->state = STAL_WAIT;
|
|
ALIVE_emitPoll(me, me->aliveTime*10, 0);
|
|
} else {
|
|
me->state = STAL_DEAD;
|
|
}
|
|
me->isAlive = false;
|
|
|
|
}
|
|
break;
|
|
|
|
case STAL_DEAD:
|
|
if (ev->id == evALborn) {
|
|
me->state = STAL_BORN;
|
|
}
|
|
break;
|
|
|
|
case STAL_ALIVE:
|
|
if (ev->id == evALpoll) {
|
|
if (me->alive.f != NULL) {
|
|
me->alive.f(me->alive.p);
|
|
}
|
|
if (me->aliveTime == 0) {
|
|
if (me->haveBreak){
|
|
me->state == STAL_BREAK;
|
|
}
|
|
} else {
|
|
ALIVE_emitPoll(me, me->aliveTime*10, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case STAL_BREAK:
|
|
if (ev->id == evALstart) {
|
|
ALIVE_emitPoll(me, me->aliveTime*10, 0);
|
|
if (me->checker) {
|
|
me->state = STAL_WAIT;
|
|
}
|
|
if (me->sender) {
|
|
me->state = STAL_ALIVE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(oldState != me->state){
|
|
switch (oldState) { // onExit
|
|
case STAL_INIT:
|
|
break;
|
|
|
|
case STAL_SETUP:
|
|
break;
|
|
|
|
case STAL_BORN:
|
|
break;
|
|
|
|
case STAL_WAIT:
|
|
break;
|
|
|
|
case STAL_DEAD:
|
|
break;
|
|
|
|
case STAL_ALIVE:
|
|
break;
|
|
|
|
case STAL_BREAK:
|
|
break;
|
|
}
|
|
|
|
switch (me->state) { // onEntry
|
|
case STAL_INIT:
|
|
break;
|
|
|
|
case STAL_SETUP:
|
|
if (me->setup.f != NULL) {
|
|
me->setup.f(me->setup.p);
|
|
}
|
|
break;
|
|
|
|
case STAL_BORN:
|
|
if (me->born.f != NULL) {
|
|
me->born.f(me->born.p);
|
|
}
|
|
break;
|
|
|
|
case STAL_WAIT:
|
|
if (me->wait.f != NULL) {
|
|
me->wait.f(me->wait.p);
|
|
}
|
|
break;
|
|
|
|
case STAL_DEAD:
|
|
if (me->dead.f != NULL) {
|
|
me->dead.f(me->dead.p);
|
|
}
|
|
break;
|
|
|
|
case STAL_ALIVE:
|
|
break;
|
|
|
|
case STAL_BREAK:
|
|
if (me->break_cb.f != NULL) {
|
|
me->break_cb.f(me->break_cb.p);
|
|
}
|
|
break;
|
|
}
|
|
|
|
processed = true;
|
|
}
|
|
return processed;
|
|
}
|
|
|
|
/*************
|
|
* Callbacks *
|
|
*************/
|
|
|
|
void ALIVE_onSetup(ALIVE* me, ALIVE_CALLBACK_FUNCTION f, void* p) {
|
|
me->setup.f = f;
|
|
me->setup.p = p;
|
|
}
|
|
|
|
void ALIVE_onBorn(ALIVE* me, ALIVE_CALLBACK_FUNCTION f, void* p) {
|
|
me->born.f = f;
|
|
me->born.p = p;
|
|
}
|
|
|
|
void ALIVE_onWait(ALIVE* me, ALIVE_CALLBACK_FUNCTION f, void* p) {
|
|
me->wait.f = f;
|
|
me->wait.p = p;
|
|
}
|
|
|
|
void ALIVE_onDead(ALIVE* me, ALIVE_CALLBACK_FUNCTION f, void* p) {
|
|
me->dead.f = f;
|
|
me->dead.p = p;
|
|
}
|
|
|
|
void ALIVE_onAlive(ALIVE* me, ALIVE_CALLBACK_FUNCTION f, void* p) {
|
|
me->alive.f = f;
|
|
me->alive.p = p;
|
|
}
|
|
|
|
void ALIVE_onBreak(ALIVE* me, ALIVE_CALLBACK_FUNCTION f, void* p) {
|
|
me->break_cb.f = f;
|
|
me->break_cb.p = p;
|
|
}
|
|
|
|
/************
|
|
* EMITTERS *
|
|
************/
|
|
|
|
void ALIVE_emitInitSender(ALIVE* me, uint16_t t, int64_t data) {
|
|
POST(me, &ALIVE_processEvent, evALinitSender, t, data);
|
|
}
|
|
|
|
void ALIVE_emitBorn(ALIVE* me, uint16_t t, int64_t data) {
|
|
POST(me, &ALIVE_processEvent, evALborn, t, data);
|
|
}
|
|
|
|
void ALIVE_emitReady(ALIVE* me, uint16_t t, int64_t data) {
|
|
POST(me, &ALIVE_processEvent, evALready, t, data);
|
|
}
|
|
|
|
void ALIVE_emitPoll(ALIVE* me, uint16_t t, int64_t data) {
|
|
POST(me, &ALIVE_processEvent, evALpoll, t, data);
|
|
}
|
|
|
|
void ALIVE_emitStart(ALIVE* me, uint16_t t, int64_t data) {
|
|
POST(me, &ALIVE_processEvent, evALstart, t, data);
|
|
}
|
|
|
|
/***********
|
|
* SETTERS *
|
|
***********/
|
|
|
|
void ALIVE_setIsAlive(ALIVE* me, bool v) {
|
|
me->isAlive = v;
|
|
}
|
|
|
|
void ALIVE_setHaveBreak(ALIVE* me, bool v) {
|
|
me->haveBreak = v;
|
|
}
|
|
|
|
void ALIVE_setAliveTime(ALIVE* me, uint8_t v) {
|
|
me->aliveTime = v;
|
|
}
|
|
|
|
void ALIVE_ISALIVE(ALIVE* me) {
|
|
ALIVE_setIsAlive(me, true);
|
|
}
|