State Machine implementation finished

Author: cloud-rocket

Event.cpp

@@ -44,13 +44,13 @@ void Event::Detach(EventListener* listener) {
 
 
 
-void Event::Notify() {
+void Event::Notify(uint16_t type) {
 
 	if (!_listeners.isEmpty()) {
 
 		for (_listeners.first(); !_listeners.isDone(); _listeners.next()) {
 
-			_listeners.currentItem()->onEvent(this);
+			_listeners.currentItem()->onEvent(this, type);
 
 		}
 	}

Event.h

@@ -7,7 +7,7 @@ class Event;
 
 class EventListener {
 protected:
-	virtual void onEvent(Event* o) = 0;
+	virtual void onEvent(Event* o, uint16_t eventType, uint32_t param1 = 0, uint32_t param2 = 0) = 0;
 
 	friend class Event;
 };
@@ -17,13 +17,15 @@ class Event {
 public:
 
 	Event();
-
+	
+	virtual uint8_t type() = 0;
+	
 	void Attach(EventListener* listener);
 	void Detach(EventListener* listener);
 	byte IsAttached(EventListener* listener);
 
 protected:
-	virtual void Notify();
+	virtual void Notify(uint16_t type);
 
 	StackArray<EventListener*> _listeners;
 };

Examples/StateMachineExample/StateMachineExample.ino

@@ -0,0 +1,117 @@
+#include <Arduino.h>
+
+#include <ctype.h>
+#include <ArduinoEssentials.h>
+#include <StateMachine.h>
+
+
+StateMachine stateMachine;
+
+// MODE A
+
+class ModeA : public StateMachineMode {
+	DECLARE_STATE(ModeA, State1);
+	DECLARE_STATE(ModeA, EndlessLoop);
+
+	BEGIN_STATES_REGISTRATION
+		ADD_STATE(stateMachine, State1);
+		ADD_STATE(stateMachine, EndlessLoop);
+	END_STATES_REGISTRATION
+};
+
+
+SM_COMMAND ModeA::State1(uint16_t eventType, uint32_t param1, uint32_t param2) {
+	Serial.println("in State1");
+
+	return SM_NEXT_STATE;
+}
+
+SM_COMMAND ModeA::EndlessLoop(uint16_t eventType, uint32_t param1, uint32_t param2) {
+	Serial.println("in EndlessLoop");
+
+	while(1)	;
+
+	return SM_DO_NOTHING;
+}
+
+
+ModeA modeA;
+
+
+// MODE B
+
+
+class ModeB : public StateMachineMode {
+	DECLARE_STATE(ModeB, StateOfB1);
+	DECLARE_STATE(ModeB, StateOfB2);
+
+	BEGIN_STATES_REGISTRATION
+		ADD_STATE(stateMachine, StateOfB1);
+		ADD_STATE(stateMachine, StateOfB2);
+	END_STATES_REGISTRATION
+
+public:
+	void begin();
+	void end();
+
+
+};
+
+
+SM_COMMAND ModeB::StateOfB1(uint16_t eventType, uint32_t param1, uint32_t param2) {
+	Serial.println("in StateOfB1");
+
+	return SM_NEXT_STATE;
+}
+
+SM_COMMAND ModeB::StateOfB2(uint16_t eventType, uint32_t param1, uint32_t param2) {
+	Serial.println("in StateOfB2");
+
+	stateMachine.setMode(modeA);
+
+	return SM_DO_NOTHING;
+}
+
+void ModeB::begin() {
+	Serial.println("ModeB::begin");
+}
+
+void ModeB::end() {
+	Serial.println("ModeB::end");
+}
+
+
+ModeB modeB;
+
+
+
+void setup() {
+
+	Serial.begin(115200);
+	Serial.println("Initializing State Machine:");
+
+	modeA.init(stateMachine);
+	modeB.init(stateMachine);
+
+	RUNTIME.Attach(&stateMachine);
+	
+	stateMachine.setMode(modeB);
+	
+	Serial.println("State Machine initialized!");
+}
+
+
+
+void loop() {
+	RUNTIME.exec();
+}
+
+int main(void) {
+
+	init();
+	setup();
+
+	while (true) {
+		loop();
+	}
+}

Runtime.cpp

@@ -10,12 +10,13 @@
 
 #include <Arduino.h>
 
+const uint8_t EVENT_TYPE_RUNTIME = 10;
 
 Runtime RUNTIME;
 
 void Runtime::exec() {
 	while (1) {
-		Notify();
+		Notify(EVENT_TYPE_RUNTIME);
 	}
 }
 

Runtime.h

@@ -10,11 +10,15 @@
 
 #include "Event.h"
 
+const extern uint8_t EVENT_TYPE_RUNTIME;
+
 extern class Runtime : public Event {
 
 public:
 
 	void exec();
+	
+	uint8_t type() {return EVENT_TYPE_RUNTIME;}
 
 } RUNTIME;
 

SoftTimer.cpp

@@ -11,6 +11,9 @@
 
 #include <Arduino.h>
 
+const uint8_t EVENT_TYPE_SOFT_TIMER = 20;
+
+
 SoftTimer TIMER;
 
 void SoftTimer::init() {
@@ -25,7 +28,7 @@ void SoftTimer::Attach(TimerListener* listener, unsigned long timerPeriod) {
 }
 
 
-void SoftTimer::Notify() {
+void SoftTimer::Notify(uint16_t type) {
 
 	if (!_listeners.isEmpty()) {
 		for (_listeners.first(); !_listeners.isDone(); _listeners.next()) {
@@ -38,7 +41,7 @@ void SoftTimer::Notify() {
 
 			if (!node->lastTimestamp || now > node->lastTimestamp + node->timerPeriod) {
 
-				node->onEvent(this);
+				node->onEvent(this, type);
 				node->lastTimestamp = now;
 
 				//DEBUG_PRINT(DEBUG_INFO,"Now=");
@@ -48,6 +51,6 @@ void SoftTimer::Notify() {
 	}
 }
 
-void SoftTimer::onEvent(Event* o) {
-	Notify();
+void SoftTimer::onEvent(Event* o, uint16_t eventType, uint32_t param1, uint32_t param2) {
+	Notify(EVENT_TYPE_SOFT_TIMER);
 }

SoftTimer.h

@@ -21,16 +21,20 @@ class TimerListener : public Event, public EventListener {
 	friend class SoftTimer;
 };
 
+const extern uint8_t EVENT_TYPE_SOFT_TIMER;
+
 extern class SoftTimer : public Event, public EventListener {
 
 public:
 	void init();
 	void Attach(TimerListener* listener, unsigned long timerPeriod);
 
+	uint8_t type() {return EVENT_TYPE_SOFT_TIMER;}
+
 
 protected:
-	void onEvent(Event* o);
-	void Notify();
+	void onEvent(Event* o, uint16_t eventType = 0, uint32_t param1 = 0, uint32_t param2 = 0);
+	void Notify(uint16_t type);
 
 } TIMER;
 

StateMachine.cpp

@@ -7,14 +7,15 @@
 
 #include "StateMachine.h"
 
+
 void StateMachineMode::init(StateMachine& stateMachine) {
 	stateMachine.addMode(*this);
 	addStates(stateMachine);
 }
 
 
 
-StateMachine::StateMachine() : _currMode(0), _totalModes(0) {
+StateMachine::StateMachine() : _currMode(UNDEFINED_MODESTATE), _totalModes(0) {
 
 	for (uint8_t i = 0; i< SM_TOTAL_MODES; i++) {
 		_totalStates[i] = 0;
@@ -28,23 +29,27 @@ StateMachine::StateMachine() : _currMode(0), _totalModes(0) {
 //	// TODO Auto-generated destructor stub
 //}
 
-void StateMachine::begin() {
-
-}
-
 
 uint8_t StateMachine::addMode(StateMachineMode& mode) {
 
 	// Store Mode object
 	_modesMap[_totalModes] = &mode;
 
+	Serial.print("Mode added - ");
+	Serial.println(_totalModes);
+
 	return _totalModes++;
 }
 
 uint8_t StateMachine::addState(StateMachineMode::STATE_FUNCTION_STATIC_T state) {
-	_statesMap[_totalModes][_totalStates[_totalModes]] = state;
+	_statesMap[_totalModes-1][_totalStates[_totalModes-1]] = state;
+
+	Serial.print("State added - ");
+	Serial.print(_totalStates[_totalModes-1]);
+	Serial.print("  mode - ");
+	Serial.println(_totalModes-1);
 
-	return _totalStates[_totalModes]++;
+	return _totalStates[_totalModes-1]++;
 }
 
 
@@ -56,11 +61,16 @@ bool StateMachine::setMode(StateMachineMode& mode, uint8_t state) {
 		}
 	}
 
+Serial.println("HERE");
+
 	return false;
 }
 
 bool StateMachine::setMode(uint8_t mode, uint8_t state) {
 
+	Serial.print("Setting mode to - ");
+	Serial.println(mode);
+
 	// Check valid input
 	if (mode >= _totalModes || (state > _totalStates[mode] && state != UNDEFINED_MODESTATE)) {
 		return false;
@@ -72,7 +82,7 @@ bool StateMachine::setMode(uint8_t mode, uint8_t state) {
 	}
 
 	// If previously set - call destructor
-	if (_modesMap[_currMode]) {
+	if (_currMode != UNDEFINED_MODESTATE) {
 		_modesMap[_currMode]->end();
 	}
 
@@ -89,8 +99,9 @@ bool StateMachine::setMode(uint8_t mode, uint8_t state) {
 bool StateMachine::setState(uint8_t state) {
 
 
+
 	// Valid input check
-	if (state > _totalStates[_currMode] && state != UNDEFINED_MODESTATE) {
+	if (_currMode == UNDEFINED_MODESTATE || (state > _totalStates[_currMode] && state != UNDEFINED_MODESTATE)) {
 		return false;
 	}
 
@@ -100,7 +111,11 @@ bool StateMachine::setState(uint8_t state) {
 }
 
 
-void StateMachine::onEvent(uint16_t eventType, uint32_t param1, uint32_t param2) {
+void StateMachine::onEvent(Event* o, uint16_t eventType, uint32_t param1, uint32_t param2) {
+
+	if (_currMode == UNDEFINED_MODESTATE) {
+		return;
+	}
 
 	StateMachineMode::STATE_FUNCTION_STATIC_T currentHandler = _statesMap[_currMode][_currState[_currMode]];