doryan/BloomPatched
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated TargetControllerConsole to use template method for triggering events for the TargetController.

Browse Source
This commit is contained in:
Nav
2021-08-20 22:53:31 +01:00
parent e3ec4e31e8
commit 092a7df675
14 changed files with 54 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/EventManager/Events/RemoveBreakpointOnTarget.hpp
View File

@@ -4,6 +4,7 @@
#include <string>
#include "Event.hpp"
#include "BreakpointRemovedOnTarget.hpp"
#include "src/Targets/TargetBreakpoint.hpp"
namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
class RemoveBreakpointOnTarget: public Event
{
public:
using TargetControllerResponseType = BreakpointRemovedOnTarget;
static inline EventType type = EventType::REMOVE_BREAKPOINT_ON_TARGET;
static inline const std::string name = "RemoveBreakpointOnTarget";
Targets::TargetBreakpoint breakpoint;

3
src/EventManager/Events/ReportTargetControllerState.hpp
View File

@@ -3,12 +3,15 @@
#include <string>
#include "Event.hpp"
#include "TargetControllerStateReported.hpp"
namespace Bloom::Events
{
class ReportTargetControllerState: public Event
{
public:
using TargetControllerResponseType = TargetControllerStateReported;
static inline EventType type = EventType::REPORT_TARGET_CONTROLLER_STATE;
static inline const std::string name = "ReportTargetControllerState";

3
src/EventManager/Events/ResumeTargetExecution.hpp
View File

@@ -4,12 +4,15 @@
#include <string>
#include "Event.hpp"
#include "TargetExecutionResumed.hpp"
namespace Bloom::Events
{
class ResumeTargetExecution: public Event
{
public:
using TargetControllerResponseType = TargetExecutionResumed;
static inline EventType type = EventType::RESUME_TARGET_EXECUTION;
static inline const std::string name = "ResumeTargetExecutionEvent";
std::optional<std::uint32_t> fromProgramCounter;

3
src/EventManager/Events/RetrieveMemoryFromTarget.hpp
View File

@@ -4,6 +4,7 @@
#include <string>
#include "Event.hpp"
#include "MemoryRetrievedFromTarget.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
class RetrieveMemoryFromTarget: public Event
{
public:
using TargetControllerResponseType = MemoryRetrievedFromTarget;
static inline EventType type = EventType::RETRIEVE_MEMORY_FROM_TARGET;
static inline const std::string name = "RetrieveMemoryFromTarget";
Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;

3
src/EventManager/Events/RetrieveRegistersFromTarget.hpp
View File

@@ -3,6 +3,7 @@
#include <string>
#include "Event.hpp"
#include "RegistersRetrievedFromTarget.hpp"
#include "src/Targets/TargetRegister.hpp"
namespace Bloom::Events
@@ -10,6 +11,8 @@ namespace Bloom::Events
class RetrieveRegistersFromTarget: public Event
{
public:
using TargetControllerResponseType = RegistersRetrievedFromTarget;
static inline EventType type = EventType::RETRIEVE_REGISTERS_FROM_TARGET;
static inline const std::string name = "RetrieveRegistersFromTarget";
Targets::TargetRegisterDescriptors descriptors;

3
src/EventManager/Events/RetrieveTargetPinStates.hpp
View File

@@ -3,12 +3,15 @@
#include <string>
#include "Event.hpp"
#include "TargetPinStatesRetrieved.hpp"
namespace Bloom::Events
{
class RetrieveTargetPinStates: public Event
{
public:
using TargetControllerResponseType = TargetPinStatesRetrieved;
static inline EventType type = EventType::RETRIEVE_TARGET_PIN_STATES;
static inline const std::string name = "RetrieveTargetPinStates";
int variantId = 0;

3
src/EventManager/Events/SetBreakpointOnTarget.hpp
View File

@@ -4,6 +4,7 @@
#include <string>
#include "Event.hpp"
#include "BreakpointSetOnTarget.hpp"
#include "src/Targets/TargetBreakpoint.hpp"
namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
class SetBreakpointOnTarget: public Event
{
public:
using TargetControllerResponseType = BreakpointSetOnTarget;
static inline EventType type = EventType::SET_BREAKPOINT_ON_TARGET;
static inline const std::string name = "SetBreakpointOnTarget";
Targets::TargetBreakpoint breakpoint;

3
src/EventManager/Events/SetProgramCounterOnTarget.hpp
View File

@@ -4,12 +4,15 @@
#include <string>
#include "Event.hpp"
#include "ProgramCounterSetOnTarget.hpp"
namespace Bloom::Events
{
class SetProgramCounterOnTarget: public Event
{
public:
using TargetControllerResponseType = ProgramCounterSetOnTarget;
static inline EventType type = EventType::SET_PROGRAM_COUNTER_ON_TARGET;
static inline const std::string name = "SetProgramCounterOnTarget";
std::uint32_t address = 0;

3
src/EventManager/Events/SetTargetPinState.hpp
View File

@@ -3,6 +3,7 @@
#include <string>
#include "Event.hpp"
#include "TargetPinStatesRetrieved.hpp"
#include "src/Targets/TargetPinDescriptor.hpp"
namespace Bloom::Events
@@ -10,6 +11,8 @@ namespace Bloom::Events
class SetTargetPinState: public Event
{
public:
using TargetControllerResponseType = TargetPinStatesRetrieved;
static inline EventType type = EventType::SET_TARGET_PIN_STATE;
static inline const std::string name = "SetTargetPinState";
int variantId = 0;

3
src/EventManager/Events/StepTargetExecution.hpp
View File

@@ -4,12 +4,15 @@
#include <string>
#include "Event.hpp"
#include "TargetExecutionResumed.hpp"
namespace Bloom::Events
{
class StepTargetExecution: public Event
{
public:
using TargetControllerResponseType = TargetExecutionResumed;
static inline EventType type = EventType::STEP_TARGET_EXECUTION;
static inline const std::string name = "StepTargetExecution";
std::optional<std::uint32_t> fromProgramCounter;

3
src/EventManager/Events/StopTargetExecution.hpp
View File

@@ -3,12 +3,15 @@
#include <string>
#include "Event.hpp"
#include "TargetExecutionStopped.hpp"
namespace Bloom::Events
{
class StopTargetExecution: public Event
{
public:
using TargetControllerResponseType = TargetExecutionStopped;
static inline EventType type = EventType::STOP_TARGET_EXECUTION;
static inline const std::string name = "StopTargetExecution";

3
src/EventManager/Events/WriteMemoryToTarget.hpp
View File

@@ -5,6 +5,7 @@
#include <utility>
#include "Event.hpp"
#include "MemoryWrittenToTarget.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Bloom::Events
@@ -12,6 +13,8 @@ namespace Bloom::Events
class WriteMemoryToTarget: public Event
{
public:
using TargetControllerResponseType = MemoryWrittenToTarget;
static inline EventType type = EventType::WRITE_MEMORY_TO_TARGET;
static inline const std::string name = "WriteMemoryToTarget";
Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;

3
src/EventManager/Events/WriteRegistersToTarget.hpp
View File

@@ -4,6 +4,7 @@
#include <utility>
#include "Event.hpp"
#include "RegistersWrittenToTarget.hpp"
#include "src/Targets/TargetRegister.hpp"
namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
class WriteRegistersToTarget: public Event
{
public:
using TargetControllerResponseType = RegistersWrittenToTarget;
static inline EventType type = EventType::WRITE_REGISTERS_TO_TARGET;
static inline const std::string name = "WriteRegistersToTarget";
Targets::TargetRegisters registers;

145
src/TargetController/TargetControllerConsole.cpp
View File

@@ -11,53 +11,28 @@ using namespace Bloom::Events;
using namespace Bloom::Exceptions;
TargetControllerState TargetControllerConsole::getTargetControllerState() {
auto getStateEvent = std::make_shared<ReportTargetControllerState>();
this->eventManager.triggerEvent(getStateEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetControllerStateReported,
TargetControllerErrorOccurred
>(this->defaultTimeout, getStateEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto stateReportedEvent = std::get<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value());
return stateReportedEvent->state;
return this->triggerTargetControllerEventAndWaitForResponse(
std::make_shared<ReportTargetControllerState>()
)->state;
}
bool TargetControllerConsole::isTargetControllerInService() noexcept {
try {
return this->getTargetControllerState() == TargetControllerState::ACTIVE;
} catch (const std::runtime_error&) {
} catch (...) {
return false;
}
}
Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
auto descriptorExtractedEvent = this->triggerTargetControllerEventAndWaitForResponse(
return this->triggerTargetControllerEventAndWaitForResponse(
std::make_shared<ExtractTargetDescriptor>()
);
return descriptorExtractedEvent->targetDescriptor;
)->targetDescriptor;
}
void TargetControllerConsole::stopTargetExecution() {
auto stopTargetEvent = std::make_shared<StopTargetExecution>();
this->eventManager.triggerEvent(stopTargetEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetExecutionStopped,
TargetControllerErrorOccurred
>(this->defaultTimeout, stopTargetEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetExecutionStopped>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(std::make_shared<StopTargetExecution>());
}
void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
@@ -67,17 +42,7 @@ void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_
resumeExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(resumeExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetExecutionResumed,
TargetControllerErrorOccurred
>(this->defaultTimeout, resumeExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(resumeExecutionEvent);
}
void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
@@ -87,56 +52,21 @@ void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> f
stepExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(stepExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetExecutionResumed,
TargetControllerErrorOccurred
>(this->defaultTimeout, stepExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(stepExecutionEvent);
}
TargetRegisters TargetControllerConsole::readRegisters(const TargetRegisterDescriptors& descriptors) {
auto readRegistersEvent = std::make_shared<RetrieveRegistersFromTarget>();
readRegistersEvent->descriptors = descriptors;
this->eventManager.triggerEvent(readRegistersEvent);
auto responseEvent = this->eventListener.waitForEvent<
RegistersRetrievedFromTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, readRegistersEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<RegistersRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<SharedEventPointer<RegistersRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->registers;
return this->triggerTargetControllerEventAndWaitForResponse(readRegistersEvent)->registers;
}
void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {
auto event = std::make_shared<WriteRegistersToTarget>();
event->registers = std::move(registers);
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
RegistersWrittenToTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<RegistersWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(event);
}
TargetMemoryBuffer TargetControllerConsole::readMemory(
@@ -149,22 +79,7 @@ TargetMemoryBuffer TargetControllerConsole::readMemory(
readMemoryEvent->startAddress = startAddress;
readMemoryEvent->bytes = bytes;
this->eventManager.triggerEvent(readMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
MemoryRetrievedFromTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, readMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<MemoryRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<SharedEventPointer<MemoryRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->data;
return this->triggerTargetControllerEventAndWaitForResponse(readMemoryEvent)->data;
}
void TargetControllerConsole::writeMemory(
@@ -177,51 +92,21 @@ void TargetControllerConsole::writeMemory(
writeMemoryEvent->startAddress = startAddress;
writeMemoryEvent->buffer = buffer;
this->eventManager.triggerEvent(writeMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
MemoryWrittenToTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, writeMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<MemoryWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(writeMemoryEvent);
}
void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<SetBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
BreakpointSetOnTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<BreakpointSetOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(event);
}
void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<RemoveBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
BreakpointRemovedOnTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<BreakpointRemovedOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(event);
}
void TargetControllerConsole::requestPinStates(int variantId) {