🎨 wip

libs/RobotKit/include/RobotController.h

@@ -306,25 +306,20 @@ class RobotController : public interface::RobotController
 		}
 
 		if (card == MagicCard::dice_roll) {
+			start = rtos::Kernel::Clock::now();
 			if (!is_autonomous_mode) {
-				start = rtos::Kernel::Clock::now();
-
 				if (start - stop > 1s) {
 					raiseAutonomousActivityModeRequested();
 				}
 			}
 
 			if (is_autonomous_mode && !is_playing) {
-				stop = rtos::Kernel::Clock::now();
-
-				if (stop - start > 2s) {
+				if (start - stop > 2s) {
 					raiseAutonomousActivityModeExited();
 				}
 			}
 
 			if (is_autonomous_mode && is_playing) {
-				start = rtos::Kernel::Clock::now();
-
 				if (start - stop > 1s) {
 					raiseAutonomousActivityModeRequested();
 				}

libs/RobotKit/include/StateMachine.h

@@ -234,7 +234,8 @@ struct StateMachine {
 			, sm::state::autonomous_activities + event<sm::event::charge_did_start> [sm::guard::is_charging {}]                                 = sm::state::charging
 			, sm::state::autonomous_activities + event<sm::event::emergency_stop>                                                               = sm::state::emergency_stopped
 			, sm::state::autonomous_activities + event<sm::event::autonomous_activities_mode_requested>                                         = sm::state::autonomous_activities
-			, sm::state::autonomous_activities + event<sm::event::autonomous_activities_mode_exited>                                            = sm::state::idle
+			, sm::state::autonomous_activities + event<sm::event::autonomous_activities_mode_exited> [sm::guard::is_not_connected {}]           = sm::state::idle
+			, sm::state::autonomous_activities + event<sm::event::autonomous_activities_mode_exited> [sm::guard::is_connected {}]               = sm::state::working
 
 			,
 

libs/RobotKit/tests/RobotController_test.h

@@ -117,6 +117,7 @@ class RobotControllerTest : public testing::Test
 	mbed::Callback<void()> on_charge_did_start {};
 	mbed::Callback<void()> on_charge_did_stop {};
 
+	uint64_t initial_now			 = 29712345;
 	bool spy_isCharging_return_value = false;
 
 	void expectedCallsStopMotors()

libs/RobotKit/tests/RobotController_test_stateAutonomousActivities.cpp

@@ -100,23 +100,28 @@ TEST_F(RobotControllerTest, stateGameEventChargeDidStartGuardIsChargingFalse)
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));
 }
 
-TEST_F(RobotControllerTest, stateGameEventAutonomousActivityRequested)
+TEST_F(RobotControllerTest, stateGameEventAutonomousActivityRequestedNotOverDelay)
 {
 	rc.state_machine.set_current_states(lksm::state::autonomous_activities);
 
+	auto not_over_maximal_delay_in_ms = 2000;
+
 	EXPECT_CALL(mock_videokit, stopVideo).Times(0);
 	EXPECT_CALL(mock_motor_left, stop).Times(0);
 	EXPECT_CALL(mock_motor_right, stop).Times(0);
 	EXPECT_CALL(mock_videokit, displayImage).Times(0);
 
+	spy_kernel_setTickCount(initial_now + not_over_maximal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));
 }
 
-TEST_F(RobotControllerTest, stateGameEventAutonomousActivityExited)
+TEST_F(RobotControllerTest, stateGameEventAutonomousActivityExitedDisconnected)
 {
-	rc.state_machine.set_current_states(lksm::state::autonomous_activities);
+	rc.state_machine.set_current_states(lksm::state::autonomous_activities, lksm::state::disconnected);
+
+	auto over_minimal_delay_in_ms = 2001;
 
 	EXPECT_CALL(mock_videokit, stopVideo).Times(AtLeast(1));
 	EXPECT_CALL(mock_motor_left, stop).Times(AtLeast(1));
@@ -128,12 +133,33 @@ TEST_F(RobotControllerTest, stateGameEventAutonomousActivityExited)
 	EXPECT_CALL(mock_videokit, playVideoOnRepeat).InSequence(on_idle_entry_sequence);
 	EXPECT_CALL(mock_lcd, turnOn).InSequence(on_idle_entry_sequence);
 
-	spy_kernel_setTickCount(29712345 + 4000);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::idle));
 }
 
+TEST_F(RobotControllerTest, stateGameEventAutonomousActivityExitedConnected)
+{
+	rc.state_machine.set_current_states(lksm::state::autonomous_activities, lksm::state::connected);
+
+	auto over_minimal_delay_in_ms = 2001;
+
+	EXPECT_CALL(mock_videokit, stopVideo).Times(AtLeast(1));
+	EXPECT_CALL(mock_motor_left, stop).Times(AtLeast(1));
+	EXPECT_CALL(mock_motor_right, stop).Times(AtLeast(1));
+
+	Sequence on_working_entry_sequence;
+	EXPECT_CALL(timeout, onTimeout).InSequence(on_working_entry_sequence);
+	EXPECT_CALL(timeout, start).InSequence(on_working_entry_sequence);
+	EXPECT_CALL(mock_videokit, displayImage).InSequence(on_working_entry_sequence);
+
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
+	rc.onMagicCardAvailable(MagicCard::dice_roll);
+
+	EXPECT_TRUE(rc.state_machine.is(lksm::state::working));
+}
+
 TEST_F(RobotControllerTest, stateGameActivityDisplayTagsChosen)
 {
 	rc.state_machine.set_current_states(lksm::state::autonomous_activities);
@@ -170,17 +196,24 @@ TEST_F(RobotControllerTest, stateGameMagicCardAvailableActivityAlreadyStarted)
 
 TEST_F(RobotControllerTest, stateGameActivityStartedBackToMenu)
 {
+	auto over_minimal_delay_in_ms = 1001;
+
 	rc.state_machine.set_current_states(lksm::state::autonomous_activities);
 
-	const std::unordered_map<MagicCard, interface::Activity *> activities {{MagicCard::number_10, &display_tag}};
+	auto set_activitykit_is_playing = [this] {
+		const std::unordered_map<MagicCard, interface::Activity *> activities {{MagicCard::number_10, &display_tag}};
+		activitykit.registerActivities(activities);
+		EXPECT_CALL(mock_videokit, displayImage).Times(1);
+		activitykit.start(MagicCard::number_10);
+	};
+	set_activitykit_is_playing();
 
-	activitykit.registerActivities(activities);
+	EXPECT_CALL(mock_videokit, stopVideo);
+	expectedCallsStopMotors();
 
 	EXPECT_CALL(mock_videokit, displayImage).Times(1);
 
-	activitykit.start(MagicCard::number_10);
-
-	spy_kernel_setTickCount(29712345 + 1001);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));

libs/RobotKit/tests/RobotController_test_stateCharging.cpp

@@ -188,13 +188,15 @@ TEST_F(RobotControllerTest, stateChargingEventAutonomousActivityRequested)
 {
 	rc.state_machine.set_current_states(lksm::state::charging);
 
+	auto over_minimal_delay_in_ms = 1001;
+
 	EXPECT_CALL(battery, level);
 	EXPECT_CALL(mock_videokit, displayImage).Times(1);
 	EXPECT_CALL(mock_lcd, turnOn).Times(AnyNumber());
 	EXPECT_CALL(timeout, onTimeout).WillOnce(GetCallback<interface::Timeout::callback_t>(&on_charging_start_timeout));
 	EXPECT_CALL(timeout, start).Times(AnyNumber());
 
-	spy_kernel_setTickCount(29712345 + 1001);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::charging));

libs/RobotKit/tests/RobotController_test_stateEmergencyStopped.cpp

@@ -172,9 +172,11 @@ TEST_F(RobotControllerTest, stateEmergencyStoppedEventAutonomousActivityRequeste
 {
 	rc.state_machine.set_current_states(lksm::state::emergency_stopped);
 
+	auto not_over_maximal_delay_in_ms = 1000;
+
 	EXPECT_CALL(mock_videokit, displayImage).Times(0);
 
-	spy_kernel_setTickCount(29712345 + 1000);
+	spy_kernel_setTickCount(initial_now + not_over_maximal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::emergency_stopped));
@@ -184,9 +186,11 @@ TEST_F(RobotControllerTest, stateEmergencyStoppedEventAutonomousActivityRequeste
 {
 	rc.state_machine.set_current_states(lksm::state::emergency_stopped);
 
+	auto over_minimal_delay_in_ms = 1001;
+
 	EXPECT_CALL(mock_videokit, displayImage).Times(1);
 
-	spy_kernel_setTickCount(29712345 + 1001);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));

libs/RobotKit/tests/RobotController_test_stateIdle.cpp

@@ -143,30 +143,32 @@ TEST_F(RobotControllerTest, stateIdleEventEmergencyStop)
 
 TEST_F(RobotControllerTest, stateIdleEventAutonomousActivityRequestedDelayNotOver)
 {
-	using namespace std::chrono;
 	rc.state_machine.set_current_states(lksm::state::idle);
 
+	auto not_over_maximal_delay_in_ms = 1000;
+
 	EXPECT_CALL(mock_videokit, displayImage).Times(0);
 
-	spy_kernel_setTickCount(29712345 + 1000);
+	spy_kernel_setTickCount(initial_now + not_over_maximal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::idle));
 }
 
 TEST_F(RobotControllerTest, stateIdleEventAutonomousActivityRequestedDelayOver)
 {
-	using namespace std::chrono;
 	rc.state_machine.set_current_states(lksm::state::idle);
 
+	auto over_minimal_delay_in_ms = 1001;
+
 	Sequence on_exit_idle_sequence;
 	EXPECT_CALL(timeout, stop).InSequence(on_exit_idle_sequence);
 	EXPECT_CALL(mock_videokit, stopVideo).InSequence(on_exit_idle_sequence);
 	expectedCallsStopMotors();
 
 	EXPECT_CALL(mock_videokit, displayImage).Times(1);
 
-	spy_kernel_setTickCount(29712345 + 1001);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));

libs/RobotKit/tests/RobotController_test_stateSleeping.cpp

@@ -115,9 +115,11 @@ TEST_F(RobotControllerTest, stateSleepingEventAutonomousActivityRequestedDelayNo
 {
 	rc.state_machine.set_current_states(lksm::state::sleeping);
 
+	auto not_over_maximal_delay_in_ms = 1000;
+
 	EXPECT_CALL(mock_videokit, displayImage).Times(0);
 
-	spy_kernel_setTickCount(29712345 + 1000);
+	spy_kernel_setTickCount(initial_now + not_over_maximal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::sleeping));
@@ -127,14 +129,16 @@ TEST_F(RobotControllerTest, stateSleepingEventAutonomousActivityRequestedDelayOv
 {
 	rc.state_machine.set_current_states(lksm::state::sleeping);
 
+	auto over_minimal_delay_in_ms = 1001;
+
 	Sequence on_exit_sleeping_sequence;
 	EXPECT_CALL(timeout, stop).InSequence(on_exit_sleeping_sequence);
 	EXPECT_CALL(mock_videokit, stopVideo).InSequence(on_exit_sleeping_sequence);
 	expectedCallsStopMotors();
 
 	EXPECT_CALL(mock_videokit, displayImage).Times(1);
 
-	spy_kernel_setTickCount(29712345 + 1001);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));

libs/RobotKit/tests/RobotController_test_stateWorking.cpp

@@ -83,9 +83,11 @@ TEST_F(RobotControllerTest, stateWorkingEventAutonomousActivityRequestedDelayNot
 {
 	rc.state_machine.set_current_states(lksm::state::working);
 
+	auto not_over_maximal_delay_in_ms = 1000;
+
 	EXPECT_CALL(mock_videokit, displayImage).Times(0);
 
-	spy_kernel_setTickCount(29712345 + 1000);
+	spy_kernel_setTickCount(initial_now + not_over_maximal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::working));
@@ -95,12 +97,14 @@ TEST_F(RobotControllerTest, stateWorkingEventAutonomousActivityRequestedDelayOve
 {
 	rc.state_machine.set_current_states(lksm::state::working);
 
+	auto over_minimal_delay_in_ms = 1001;
+
 	Sequence on_exit_working_sequence;
 	EXPECT_CALL(timeout, stop).InSequence(on_exit_working_sequence);
 
 	EXPECT_CALL(mock_videokit, displayImage).Times(1);
 
-	spy_kernel_setTickCount(29712345 + 1001);
+	spy_kernel_setTickCount(initial_now + over_minimal_delay_in_ms);
 	rc.onMagicCardAvailable(MagicCard::dice_roll);
 
 	EXPECT_TRUE(rc.state_machine.is(lksm::state::autonomous_activities));

libs/RobotKit/tests/StateMachine_test.cpp

@@ -602,9 +602,9 @@ TEST_F(StateMachineTest, stateGameEventAutonomousActivityRequested)
 	EXPECT_TRUE(sm.is(lksm::state::autonomous_activities));
 }
 
-TEST_F(StateMachineTest, stateGameEventAutonomousActivityExited)
+TEST_F(StateMachineTest, stateGameEventAutonomousActivityExitedDisconnected)
 {
-	sm.set_current_states(lksm::state::autonomous_activities);
+	sm.set_current_states(lksm::state::autonomous_activities, lksm::state::disconnected);
 
 	EXPECT_CALL(mock_rc, stopAutonomousActivityMode).Times(1);
 	EXPECT_CALL(mock_rc, startWaitingBehavior).Times(1);
@@ -613,3 +613,17 @@ TEST_F(StateMachineTest, stateGameEventAutonomousActivityExited)
 
 	EXPECT_TRUE(sm.is(lksm::state::idle));
 }
+
+TEST_F(StateMachineTest, stateGameEventAutonomousActivityExitedConnected)
+{
+	sm.set_current_states(lksm::state::autonomous_activities, lksm::state::connected);
+
+	EXPECT_CALL(mock_rc, isBleConnected).WillRepeatedly(Return(true));
+
+	EXPECT_CALL(mock_rc, stopAutonomousActivityMode).Times(1);
+	EXPECT_CALL(mock_rc, startWorkingBehavior).Times(1);
+
+	sm.process_event(lksm::event::autonomous_activities_mode_exited {});
+
+	EXPECT_TRUE(sm.is(lksm::state::working));
+}