Replaced RetrieveStackPointerFromTarget event with TC command

src/EventManager/Events/Event.hpp

@@ -32,8 +32,6 @@ namespace Bloom::Events
         EXTRACT_TARGET_DESCRIPTOR,
         TARGET_DESCRIPTOR_EXTRACTED,
         INSIGHT_THREAD_STATE_CHANGED,
-        RETRIEVE_STACK_POINTER_FROM_TARGET,
-        STACK_POINTER_RETRIEVED_FROM_TARGET,
         TARGET_RESET,
     };
 

src/EventManager/Events/Events.hpp

@@ -19,8 +19,6 @@
 #include "ExtractTargetDescriptor.hpp"
 #include "TargetDescriptorExtracted.hpp"
 #include "InsightThreadStateChanged.hpp"
-#include "RetrieveStackPointerFromTarget.hpp"
-#include "StackPointerRetrievedFromTarget.hpp"
 #include "TargetReset.hpp"
 
 namespace Bloom::Events

src/EventManager/Events/RetrieveStackPointerFromTarget.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Event.hpp"
-#include "StackPointerRetrievedFromTarget.hpp"
-
-namespace Bloom::Events
-{
-    class RetrieveStackPointerFromTarget: public Event
-    {
-    public:
-        using TargetControllerResponseType = StackPointerRetrievedFromTarget;
-
-        static constexpr EventType type = EventType::RETRIEVE_STACK_POINTER_FROM_TARGET;
-        static inline const std::string name = "RetrieveStackPointerFromTarget";
-
-        [[nodiscard]] EventType getType() const override {
-            return RetrieveStackPointerFromTarget::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return RetrieveStackPointerFromTarget::name;
-        }
-    };
-}

src/EventManager/Events/StackPointerRetrievedFromTarget.hpp

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Event.hpp"
-
-namespace Bloom::Events
-{
-    class StackPointerRetrievedFromTarget: public Event
-    {
-    public:
-        static constexpr EventType type = EventType::STACK_POINTER_RETRIEVED_FROM_TARGET;
-        static inline const std::string name = "StackPointerRetrievedFromTarget";
-        std::uint32_t stackPointer = 0;
-
-        [[nodiscard]] EventType getType() const override {
-            return StackPointerRetrievedFromTarget::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return StackPointerRetrievedFromTarget::name;
-        }
-    };
-}

src/TargetController/Commands/CommandTypes.hpp

@@ -22,5 +22,6 @@ namespace Bloom::TargetController::Commands
         SET_PROGRAM_COUNTER,
         GET_TARGET_PIN_STATES,
         SET_TARGET_PIN_STATE,
+        GET_TARGET_STACK_POINTER,
     };
 }

src/TargetController/Commands/GetTargetStackPointer.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Command.hpp"
+
+#include "src/TargetController/Responses/TargetStackPointer.hpp"
+
+namespace Bloom::TargetController::Commands
+{
+    class GetTargetStackPointer: public Command
+    {
+    public:
+        using SuccessResponseType = Responses::TargetStackPointer;
+
+        static constexpr CommandType type = CommandType::GET_TARGET_STACK_POINTER;
+        static inline const std::string name = "GetTargetStackPointer";
+
+        [[nodiscard]] CommandType getType() const override {
+            return GetTargetStackPointer::type;
+        }
+
+        [[nodiscard]] bool requiresStoppedTargetState() const override {
+            return true;
+        }
+    };
+}

src/TargetController/Responses/ResponseTypes.hpp

@@ -12,5 +12,6 @@ namespace Bloom::TargetController::Responses
         TARGET_MEMORY_READ,
         TARGET_STATE,
         TARGET_PIN_STATES,
+        TARGET_STACK_POINTER,
     };
 }

src/TargetController/Responses/TargetStackPointer.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Response.hpp"
+
+namespace Bloom::TargetController::Responses
+{
+    class TargetStackPointer: public Response
+    {
+    public:
+        static constexpr ResponseType type = ResponseType::TARGET_STACK_POINTER;
+
+        std::uint32_t stackPointer;
+
+        explicit TargetStackPointer(std::uint32_t stackPointer)
+            : stackPointer(stackPointer)
+        {}
+
+        [[nodiscard]] ResponseType getType() const override {
+            return TargetStackPointer::type;
+        }
+    };
+}

src/TargetController/TargetControllerComponent.cpp

@@ -36,11 +36,13 @@ namespace Bloom::TargetController
     using Commands::SetProgramCounter;
     using Commands::GetTargetPinStates;
     using Commands::SetTargetPinState;
+    using Commands::GetTargetStackPointer;
 
     using Responses::Response;
     using Responses::TargetRegistersRead;
     using Responses::TargetMemoryRead;
     using Responses::TargetPinStates;
+    using Responses::TargetStackPointer;
 
     TargetControllerComponent::TargetControllerComponent(
         const ProjectConfig& projectConfig,
@@ -405,10 +407,10 @@ namespace Bloom::TargetController
         this->deregisterCommandHandler(SetProgramCounter::type);
         this->deregisterCommandHandler(GetTargetPinStates::type);
         this->deregisterCommandHandler(SetTargetPinState::type);
+        this->deregisterCommandHandler(GetTargetStackPointer::type);
 
         this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
         this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
-        this->eventListener->deregisterCallbacksForEventType<Events::RetrieveStackPointerFromTarget>();
 
         this->lastTargetState = TargetState::UNKNOWN;
         this->cachedTargetDescriptor = std::nullopt;
@@ -481,6 +483,10 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::handleSetTargetPinState, this, std::placeholders::_1)
         );
 
+        this->registerCommandHandler<GetTargetStackPointer>(
+            std::bind(&TargetControllerComponent::handleGetTargetStackPointer, this, std::placeholders::_1)
+        );
+
         this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
             std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
         );
@@ -489,10 +495,6 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::onExtractTargetDescriptor, this, std::placeholders::_1)
         );
 
-        this->eventListener->registerCallbackForEventType<Events::RetrieveStackPointerFromTarget>(
-            std::bind(&TargetControllerComponent::onRetrieveStackPointerEvent, this, std::placeholders::_1)
-        );
-
         TargetControllerComponent::state = TargetControllerState::ACTIVE;
         EventManager::triggerEvent(
             std::make_shared<TargetControllerStateChanged>(TargetControllerComponent::state)
@@ -889,23 +891,9 @@ namespace Bloom::TargetController
         return std::make_unique<Response>();
     }
 
-    void TargetControllerComponent::onRetrieveStackPointerEvent(const Events::RetrieveStackPointerFromTarget& event) {
+    std::unique_ptr<TargetStackPointer> TargetControllerComponent::handleGetTargetStackPointer(
-        try {
+        GetTargetStackPointer& command
-            if (this->target->getState() != TargetState::STOPPED) {
+    ) {
-                throw TargetOperationFailure(
+        return std::make_unique<TargetStackPointer>(this->target->getStackPointer());
-                    "Invalid target state - target must be stopped before stack pointer can be retrieved"
-                );
-            }
-
-            auto stackPointerRetrieved = std::make_shared<Events::StackPointerRetrievedFromTarget>();
-            stackPointerRetrieved->correlationId = event.id;
-            stackPointerRetrieved->stackPointer = this->target->getStackPointer();
-
-            EventManager::triggerEvent(stackPointerRetrieved);
-
-        } catch (const TargetOperationFailure& exception) {
-            Logger::error("Failed to retrieve stack pointer value from target - " + exception.getMessage());
-            this->emitErrorEvent(event.id, exception.getMessage());
-        }
     }
 }

src/TargetController/TargetControllerComponent.hpp

@@ -32,6 +32,7 @@
 #include "Commands/SetProgramCounter.hpp"
 #include "Commands/GetTargetPinStates.hpp"
 #include "Commands/SetTargetPinState.hpp"
+#include "Commands/GetTargetStackPointer.hpp"
 
 // Responses
 #include "Responses/Response.hpp"
@@ -39,6 +40,7 @@
 #include "Responses/TargetRegistersRead.hpp"
 #include "Responses/TargetMemoryRead.hpp"
 #include "Responses/TargetPinStates.hpp"
+#include "Responses/TargetStackPointer.hpp"
 
 #include "TargetControllerState.hpp"
 
@@ -317,13 +319,8 @@ namespace Bloom::TargetController
         std::unique_ptr<Responses::Response> handleSetProgramCounter(Commands::SetProgramCounter& command);
         std::unique_ptr<Responses::TargetPinStates> handleGetTargetPinStates(Commands::GetTargetPinStates& command);
         std::unique_ptr<Responses::Response> handleSetTargetPinState(Commands::SetTargetPinState& command);
-
+        std::unique_ptr<Responses::TargetStackPointer> handleGetTargetStackPointer(
-        /**
+            Commands::GetTargetStackPointer& command
-         * Will retrieve the current stack pointer from the target. Will emit a StackPointerRetrievedFromTarget event
+        );
-         * containing the retrieved stack pointer value.
-         *
-         * @param event
-         */
-        void onRetrieveStackPointerEvent(const Events::RetrieveStackPointerFromTarget& event);
     };
 }

src/TargetController/TargetControllerConsole.cpp

@@ -19,6 +19,7 @@
 #include "Commands/SetProgramCounter.hpp"
 #include "Commands/GetTargetPinStates.hpp"
 #include "Commands/SetTargetPinState.hpp"
+#include "Commands/GetTargetStackPointer.hpp"
 
 #include "src/Logger/Logger.hpp"
 
@@ -42,6 +43,7 @@ namespace Bloom::TargetController
     using Commands::SetProgramCounter;
     using Commands::GetTargetPinStates;
     using Commands::SetTargetPinState;
+    using Commands::GetTargetStackPointer;
 
     TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
         : eventListener(eventListener)
@@ -184,8 +186,9 @@ namespace Bloom::TargetController
     }
 
     std::uint32_t TargetControllerConsole::getStackPointer() {
-        return this->triggerTargetControllerEventAndWaitForResponse(
+        return this->commandManager.sendCommandAndWaitForResponse(
-            std::make_shared<RetrieveStackPointerFromTarget>()
+            std::make_unique<GetTargetStackPointer>(),
+            this->defaultTimeout
         )->stackPointer;
     }