C++ Thread Statemachine with Timer - c++

Question

Explanation part:
I tried to read several articles with threads but I quite new to this topic therefore I'm not sure if I can accomplish what I think about.
I already implemented an object orientated state machine for detection of movement based on this tutorial C++ State machine implementation
There is also a tutorial for multi-threading with state machines but the example is a bit to complex for me and implemented for windows so for now I'm trying to do it myself. The goal is to have several final state machines running parallel for labelling of sensor information. I thought that multi-threading is needed because events will arrive asynchronously and it shall be ensured that every information will be processed (Queue has to be implemented also).
As you can see in the picture my FSM has 4 states which should be realized within one thread. It will wait for an event (movement or timer) to happen and transform to the next state. The states are saved within an object and the transition is based on an object function.
Question part:
The movement event will be triggered from outside (receiving of sensor event).
Depending on the event I can execute the corresponding object function change into the next state.
But how can I realize that a timer runs after triggering a certain state which eventually will lead to the previous state. Also the timer has to be stopped if another event happens asynchronous. Should this be handled within the thread or outside?

Answer 1

I see no motivation to involve multi-threading in this scenario. Therefore, "thread safety" is not an issue. You will define some software object which represents "the state machine" with its internal state, and two methods that can be called, one for each possible notification. These should be handled serially: a message arrives (in a thread-safe queue) to tell you the timer went off, or a message arrives to tell you about the alarm, and you pop and process those messages one at a time. Or, you can use a mutex within the methods to ensure that two method calls are never attempted simultaneously ... if that's an issue, and I see no reason for it to be. Just do all of this in one thread and be done.
Apparently, your state machine receives two notifications: (1) that the timer has just gone off, and (2) that the sensor/alarm has something to report.
And then, you simply work out the logic that needs to happen, for each of these, depending on (1) the current state, and (2) various internal variables The logic within your state-machine handles both of these: nothing is actually being done in parallel.
case state == MOVING_BETWEEN_ROOM:
case stimulus == TIMER_POP:
timer_counter++;
if timer_counter > 1 then {
state = UNSURE_MOVEMENT;
timer_counter = 0; // maybe?
}
case stimulus == ALARM:
timer_counter = 0;
if current_room == room_last_alarm {
same_room_count++;
if in_same_room_count > n then {
state = MOVING_SAME_ROOM;
in_same_room_count = 0; // maybe???
}
} else {
in_same_room_count = 0;
room_last_alarm = current_room;
}
... and, so on. I'm not saying that the above logic is correct, but it should point you in the right direction.