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

Introduced the TargetControllerConsole class to provide access to common functionality within the TargetController.

Browse Source
This commit is contained in:
Nav
2021-04-24 20:23:17 +01:00
parent 03a2bfab57
commit fa2a3f67db
10 changed files with 378 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -63,6 +63,7 @@ add_executable(Bloom
src/Application.cpp
src/DebugToolDrivers/USB/UsbDevice.cpp
src/TargetController/TargetController.cpp
src/TargetController/TargetControllerConsole.cpp
src/EventManager/EventListener.cpp
src/EventManager/EventManager.cpp
src/DebugServers/DebugServer.cpp

173
src/DebugServers/DebugServer.cpp
View File

@@ -58,176 +58,3 @@ void DebugServer::shutdown() {
void DebugServer::onShutdownDebugServerEvent(EventPointer<Events::ShutdownDebugServer> event) {
this->shutdown();
}
void DebugServer::stopTargetExecution() {
auto stopTargetEvent = std::make_shared<Events::StopTargetExecution>();
this->eventManager.triggerEvent(stopTargetEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::TargetExecutionStopped,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), stopTargetEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionStopped>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void DebugServer::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
auto resumeExecutionEvent = std::make_shared<Events::ResumeTargetExecution>();
if (fromAddress.has_value()) {
resumeExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(resumeExecutionEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::TargetExecutionResumed,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), resumeExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void DebugServer::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
auto stepExecutionEvent = std::make_shared<Events::StepTargetExecution>();
if (fromAddress.has_value()) {
stepExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(stepExecutionEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::TargetExecutionResumed,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), stepExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
TargetRegisters DebugServer::readGeneralRegistersFromTarget(TargetRegisterDescriptors descriptors) {
auto readRegistersEvent = std::make_shared<Events::RetrieveRegistersFromTarget>();
readRegistersEvent->descriptors = descriptors;
this->eventManager.triggerEvent(readRegistersEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::RegistersRetrievedFromTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), readRegistersEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<EventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value());
return retrievedRegistersEvent->registers;
}
void DebugServer::writeGeneralRegistersToTarget(TargetRegisters registers) {
auto event = std::make_shared<Events::WriteRegistersToTarget>();
event->registers = registers;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener->waitForEvent<
Events::RegistersWrittenToTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::RegistersWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
TargetMemoryBuffer DebugServer::readMemoryFromTarget(TargetMemoryType memoryType, std::uint32_t startAddress, std::uint32_t bytes) {
auto readMemoryEvent = std::make_shared<Events::RetrieveMemoryFromTarget>();
readMemoryEvent->memoryType = memoryType;
readMemoryEvent->startAddress = startAddress;
readMemoryEvent->bytes = bytes;
this->eventManager.triggerEvent(readMemoryEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::MemoryRetrievedFromTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), readMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<EventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value());
return retrievedRegistersEvent->data;
}
void DebugServer::writeMemoryToTarget(
TargetMemoryType memoryType,
std::uint32_t startAddress,
const TargetMemoryBuffer& buffer
) {
auto writeMemoryEvent = std::make_shared<Events::WriteMemoryToTarget>();
writeMemoryEvent->memoryType = memoryType;
writeMemoryEvent->startAddress = startAddress;
writeMemoryEvent->buffer = buffer;
this->eventManager.triggerEvent(writeMemoryEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::MemoryWrittenToTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), writeMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::MemoryWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void DebugServer::setBreakpointOnTarget(TargetBreakpoint breakpoint) {
auto event = std::make_shared<Events::SetBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener->waitForEvent<
Events::BreakpointSetOnTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::BreakpointSetOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void DebugServer::removeBreakpointOnTarget(TargetBreakpoint breakpoint) {
auto event = std::make_shared<Events::RemoveBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener->waitForEvent<
Events::BreakpointRemovedOnTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::BreakpointRemovedOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}

75
src/DebugServers/DebugServer.hpp
View File

@@ -4,6 +4,7 @@
#include <functional>
#include <cstdint>
#include "src/TargetController/TargetControllerConsole.hpp"
#include "src/EventManager/Events/Events.hpp"
#include "src/EventManager/EventManager.hpp"
#include "src/Exceptions/DebugServerInterrupted.hpp"
@@ -75,6 +76,11 @@ namespace Bloom::DebugServers
EventManager& eventManager;
EventListenerPointer eventListener = std::make_shared<EventListener>("DebugServerEventListener");
TargetControllerConsole targetControllerConsole = TargetControllerConsole(
this->eventManager,
*(this->eventListener)
);
/**
* Enables the interruption of any blocking file IO.
*/
@@ -99,75 +105,6 @@ namespace Bloom::DebugServers
*/
virtual void close() = 0;
/**
* Requests the TargetController to halt execution on the target.
*/
void stopTargetExecution();
/**
* Requests the TargetController to continue execution on the target.
*
* @param fromAddress
*/
void continueTargetExecution(std::optional<std::uint32_t> fromAddress);
/**
* Requests the TargetController to step execution on the target.
*
* @param fromAddress
*/
void stepTargetExecution(std::optional<std::uint32_t> fromAddress);
/**
* Requests the TargetController to read register values from the target.
*
* @param descriptors
* Descriptors of the registers to read.
*
* @return
*/
TargetRegisters readGeneralRegistersFromTarget(TargetRegisterDescriptors descriptors);
/**
* Requests the TargetController to write register values to the target.
*
* @param registers
*/
void writeGeneralRegistersToTarget(TargetRegisters registers);
/**
* Requests the TargetController to read memory from the target.
*
* @param memoryType
* @param startAddress
* @param bytes
* @return
*/
TargetMemoryBuffer readMemoryFromTarget(TargetMemoryType memoryType, std::uint32_t startAddress, std::uint32_t bytes);
/**
* Requests the TargetController to write memory to the target.
*
* @param memoryType
* @param startAddress
* @param buffer
*/
void writeMemoryToTarget(TargetMemoryType memoryType, std::uint32_t startAddress, const TargetMemoryBuffer& buffer);
/**
* Requests the TargetController to set a breakpoint on the target.
*
* @param breakpoint
*/
void setBreakpointOnTarget(TargetBreakpoint breakpoint);
/**
* Requests the TargetController to remove a breakpoint from the target.
*
* @param breakpoint
*/
void removeBreakpointOnTarget(TargetBreakpoint breakpoint);
public:
DebugServer(EventManager& eventManager): eventManager(eventManager) {};

20
src/DebugServers/GdbRsp/GdbRspDebugServer.cpp
View File

@@ -238,7 +238,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& pa
}
}
auto registerSet = this->readGeneralRegistersFromTarget(descriptors);
auto registerSet = this->targetControllerConsole.readGeneralRegisters(descriptors);
auto registerNumberToDescriptorMapping = this->getRegisterNumberToDescriptorMapping();
/*
@@ -297,7 +297,9 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::WriteGeneralRegisters& p
try {
auto registerDescriptor = this->getRegisterDescriptorFromNumber(packet.registerNumber);
this->writeGeneralRegistersToTarget({TargetRegister(registerDescriptor, packet.registerValue)});
this->targetControllerConsole.writeGeneralRegisters({
TargetRegister(registerDescriptor, packet.registerValue)
});
this->clientConnection->writePacket(ResponsePacket({'O', 'K'}));
} catch (const Exception& exception) {
@@ -310,7 +312,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ContinueExecution& packe
Logger::debug("Handling ContinueExecution packet");
try {
this->continueTargetExecution(packet.fromProgramCounter);
this->targetControllerConsole.continueTargetExecution(packet.fromProgramCounter);
this->clientConnection->waitingForBreak = true;
} catch (const Exception& exception) {
@@ -323,7 +325,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::StepExecution& packet) {
Logger::debug("Handling StepExecution packet");
try {
this->stepTargetExecution(packet.fromProgramCounter);
this->targetControllerConsole.stepTargetExecution(packet.fromProgramCounter);
this->clientConnection->waitingForBreak = true;
} catch (const Exception& exception) {
@@ -338,7 +340,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadMemory& packet) {
try {
auto memoryType = this->getMemoryTypeFromGdbAddress(packet.startAddress);
auto startAddress = this->removeMemoryTypeIndicatorFromGdbAddress(packet.startAddress);
auto memoryBuffer = this->readMemoryFromTarget(memoryType, startAddress, packet.bytes);
auto memoryBuffer = this->targetControllerConsole.readMemory(memoryType, startAddress, packet.bytes);
auto hexMemoryBuffer = Packet::dataToHex(memoryBuffer);
this->clientConnection->writePacket(
@@ -357,7 +359,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::WriteMemory& packet) {
try {
auto memoryType = this->getMemoryTypeFromGdbAddress(packet.startAddress);
auto startAddress = this->removeMemoryTypeIndicatorFromGdbAddress(packet.startAddress);
this->writeMemoryToTarget(memoryType, startAddress, packet.buffer);
this->targetControllerConsole.writeMemory(memoryType, startAddress, packet.buffer);
this->clientConnection->writePacket(ResponsePacket({'O', 'K'}));
@@ -373,7 +375,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::SetBreakpoint& packet) {
try {
auto breakpoint = TargetBreakpoint();
breakpoint.address = packet.address;
this->setBreakpointOnTarget(breakpoint);
this->targetControllerConsole.setBreakpoint(breakpoint);
this->clientConnection->writePacket(ResponsePacket({'O', 'K'}));
@@ -389,7 +391,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::RemoveBreakpoint& packet
try {
auto breakpoint = TargetBreakpoint();
breakpoint.address = packet.address;
this->removeBreakpointOnTarget(breakpoint);
this->targetControllerConsole.removeBreakpoint(breakpoint);
this->clientConnection->writePacket(ResponsePacket({'O', 'K'}));
@@ -403,7 +405,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::InterruptExecution& pack
Logger::debug("Handling InterruptExecution packet");
try {
this->stopTargetExecution();
this->targetControllerConsole.stopTargetExecution();
this->clientConnection->writePacket(TargetStopped(Signal::INTERRUPTED));
} catch (const Exception& exception) {

20
src/Insight/Insight.cpp
View File

@@ -46,7 +46,7 @@ void Insight::startup() {
std::bind(&Insight::onTargetControllerStateChangedEvent, this, std::placeholders::_1)
);
auto targetDescriptor = this->getTargetDescriptor();
auto targetDescriptor = this->targetControllerConsole.getTargetDescriptor();
std::string qtAppName = "Bloom";
char* appArguments[] = {qtAppName.data()};
@@ -91,24 +91,6 @@ void Insight::startup() {
connect(&(this->mainWindow), &InsightWindow::setTargetPinState, worker, &InsightWorker::requestPinStateUpdate);
}
Targets::TargetDescriptor Insight::getTargetDescriptor() {
auto extractEvent = std::make_shared<Events::ExtractTargetDescriptor>();
this->eventManager.triggerEvent(extractEvent);
auto responseEvent = this->eventListener->waitForEvent<
Events::TargetDescriptorExtracted,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), extractEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto descriptorExtracted = std::get<EventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value());
return descriptorExtracted->targetDescriptor;
}
void Insight::shutdown() {
if (this->getState() == ThreadState::STOPPED) {
return;

11
src/Insight/Insight.hpp
View File

@@ -2,13 +2,13 @@
#include <QtCore>
#include <QApplication>
#include "UserInterfaces/InsightWindow/InsightWindow.hpp"
#include "src/Helpers/Thread.hpp"
#include "src/ApplicationConfig.hpp"
#include "src/EventManager/EventManager.hpp"
#include "src/EventManager/EventListener.hpp"
#include "src/Targets/TargetDescriptor.hpp"
#include "src/TargetController/TargetControllerConsole.hpp"
namespace Bloom
{
@@ -34,6 +34,11 @@ namespace Bloom
QApplication* application = nullptr;
InsightWindow mainWindow;
TargetControllerConsole targetControllerConsole = TargetControllerConsole(
this->eventManager,
*(this->eventListener)
);
/**
* Insight consists of two threads - the main thread where the main Qt event loop runs (for the GUI), and
* a single worker thread to handle any blocking/time-expensive operations.
@@ -42,8 +47,6 @@ namespace Bloom
void startup();
Targets::TargetDescriptor getTargetDescriptor();
public:
Insight(EventManager& eventManager): eventManager(eventManager) {};

12
src/Insight/InsightWorker.cpp
View File

@@ -43,10 +43,7 @@ void InsightWorker::startup() {
}
void InsightWorker::requestPinStates(int variantId) {
auto requestEvent = std::make_shared<Events::RetrieveTargetPinStates>();
requestEvent->variantId = variantId;
this->eventManager.triggerEvent(requestEvent);
this->targetControllerConsole.requestPinStates(variantId);
}
void InsightWorker::requestPinStateUpdate(
@@ -54,12 +51,7 @@ void InsightWorker::requestPinStateUpdate(
Bloom::Targets::TargetPinDescriptor pinDescriptor,
Bloom::Targets::TargetPinState pinState
) {
auto updateEvent = std::make_shared<Events::SetTargetPinState>();
updateEvent->variantId = variantId;
updateEvent->pinDescriptor = pinDescriptor;
updateEvent->pinState = pinState;
this->eventManager.triggerEvent(updateEvent);
this->targetControllerConsole.setPinState(variantId, pinDescriptor, pinState);
}
void InsightWorker::onTargetStoppedEvent(EventPointer<TargetExecutionStopped> event) {

6
src/Insight/InsightWorker.hpp
View File

@@ -8,6 +8,7 @@
#include "src/ApplicationConfig.hpp"
#include "src/EventManager/EventManager.hpp"
#include "src/EventManager/EventListener.hpp"
#include "src/TargetController/TargetControllerConsole.hpp"
namespace Bloom
{
@@ -25,6 +26,11 @@ namespace Bloom
EventManager& eventManager;
EventListenerPointer eventListener = std::make_shared<EventListener>("InsightWorkerEventListener");
TargetControllerConsole targetControllerConsole = TargetControllerConsole(
this->eventManager,
*(this->eventListener)
);
QTimer* eventDispatchTimer = nullptr;
void onTargetStoppedEvent(EventPointer<TargetExecutionStopped> event);

217
src/TargetController/TargetControllerConsole.cpp Normal file
View File

@@ -0,0 +1,217 @@
#include <cstdint>
#include "TargetControllerConsole.hpp"
#include "src/EventManager/Events/Events.hpp"
#include "src/Logger/Logger.hpp"
using namespace Bloom;
Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
auto extractEvent = std::make_shared<Events::ExtractTargetDescriptor>();
this->eventManager.triggerEvent(extractEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetDescriptorExtracted,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), extractEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto descriptorExtracted = std::get<EventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value());
return descriptorExtracted->targetDescriptor;
}
void TargetControllerConsole::stopTargetExecution() {
auto stopTargetEvent = std::make_shared<Events::StopTargetExecution>();
this->eventManager.triggerEvent(stopTargetEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetExecutionStopped,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), stopTargetEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionStopped>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
auto resumeExecutionEvent = std::make_shared<Events::ResumeTargetExecution>();
if (fromAddress.has_value()) {
resumeExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(resumeExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetExecutionResumed,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), resumeExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
auto stepExecutionEvent = std::make_shared<Events::StepTargetExecution>();
if (fromAddress.has_value()) {
stepExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(stepExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetExecutionResumed,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), stepExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
TargetRegisters TargetControllerConsole::readGeneralRegisters(TargetRegisterDescriptors descriptors) {
auto readRegistersEvent = std::make_shared<Events::RetrieveRegistersFromTarget>();
readRegistersEvent->descriptors = descriptors;
this->eventManager.triggerEvent(readRegistersEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::RegistersRetrievedFromTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), readRegistersEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<EventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value());
return retrievedRegistersEvent->registers;
}
void TargetControllerConsole::writeGeneralRegisters(TargetRegisters registers) {
auto event = std::make_shared<Events::WriteRegistersToTarget>();
event->registers = registers;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
Events::RegistersWrittenToTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::RegistersWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
TargetMemoryBuffer TargetControllerConsole::readMemory(
TargetMemoryType memoryType,
std::uint32_t startAddress,
std::uint32_t bytes
) {
auto readMemoryEvent = std::make_shared<Events::RetrieveMemoryFromTarget>();
readMemoryEvent->memoryType = memoryType;
readMemoryEvent->startAddress = startAddress;
readMemoryEvent->bytes = bytes;
this->eventManager.triggerEvent(readMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::MemoryRetrievedFromTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), readMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<EventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value());
return retrievedRegistersEvent->data;
}
void TargetControllerConsole::writeMemory(
TargetMemoryType memoryType,
std::uint32_t startAddress,
const TargetMemoryBuffer& buffer
) {
auto writeMemoryEvent = std::make_shared<Events::WriteMemoryToTarget>();
writeMemoryEvent->memoryType = memoryType;
writeMemoryEvent->startAddress = startAddress;
writeMemoryEvent->buffer = buffer;
this->eventManager.triggerEvent(writeMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::MemoryWrittenToTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), writeMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::MemoryWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<Events::SetBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
Events::BreakpointSetOnTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::BreakpointSetOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<Events::RemoveBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
Events::BreakpointRemovedOnTarget,
Events::TargetControllerErrorOccurred
>(std::chrono::milliseconds(5000), event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::BreakpointRemovedOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::requestPinStates(int variantId) {
auto requestEvent = std::make_shared<Events::RetrieveTargetPinStates>();
requestEvent->variantId = variantId;
this->eventManager.triggerEvent(requestEvent);
}
void TargetControllerConsole::setPinState(int variantId, TargetPinDescriptor pinDescriptor, TargetPinState pinState) {
auto updateEvent = std::make_shared<Events::SetTargetPinState>();
updateEvent->variantId = variantId;
updateEvent->pinDescriptor = pinDescriptor;
updateEvent->pinState = pinState;
this->eventManager.triggerEvent(updateEvent);
}

126
src/TargetController/TargetControllerConsole.hpp Normal file
View File

@@ -0,0 +1,126 @@
#pragma once
#include <cstdint>
#include <optional>
#include "src/EventManager/EventListener.hpp"
#include "src/EventManager/EventManager.hpp"
#include "src/Targets/TargetRegister.hpp"
#include "src/Targets/TargetMemory.hpp"
#include "src/Targets/TargetBreakpoint.hpp"
#include "src/Targets/TargetVariant.hpp"
#include "src/Targets/TargetState.hpp"
#include "src/Targets/TargetPinDescriptor.hpp"
namespace Bloom
{
using namespace Targets;
/**
* The TargetControllerConsole provides an interface to the TargetController, for components within Bloom that
* require access to common functionality from the TargetController.
*/
class TargetControllerConsole
{
private:
EventManager& eventManager;
EventListener& eventListener;
public:
TargetControllerConsole(EventManager& eventManager, EventListener& eventListener):
eventManager(eventManager), eventListener(eventListener) {};
/**
* Requests the TargetDescriptor from the TargetController
*
* @return
*/
TargetDescriptor getTargetDescriptor();
/**
* Requests the TargetController to halt execution on the target.
*/
void stopTargetExecution();
/**
* Requests the TargetController to continue execution on the target.
*
* @param fromAddress
*/
void continueTargetExecution(std::optional<std::uint32_t> fromAddress);
/**
* Requests the TargetController to step execution on the target.
*
* @param fromAddress
*/
void stepTargetExecution(std::optional<std::uint32_t> fromAddress);
/**
* Requests the TargetController to read register values from the target.
*
* @param descriptors
* Descriptors of the registers to read.
*
* @return
*/
TargetRegisters readGeneralRegisters(TargetRegisterDescriptors descriptors);
/**
* Requests the TargetController to write register values to the target.
*
* @param registers
*/
void writeGeneralRegisters(TargetRegisters registers);
/**
* Requests the TargetController to read memory from the target.
*
* @param memoryType
* @param startAddress
* @param bytes
* @return
*/
TargetMemoryBuffer readMemory(TargetMemoryType memoryType, std::uint32_t startAddress, std::uint32_t bytes);
/**
* Requests the TargetController to write memory to the target.
*
* @param memoryType
* @param startAddress
* @param buffer
*/
void writeMemory(TargetMemoryType memoryType, std::uint32_t startAddress, const TargetMemoryBuffer& buffer);
/**
* Requests the TargetController to set a breakpoint on the target.
*
* @param breakpoint
*/
void setBreakpoint(TargetBreakpoint breakpoint);
/**
* Requests the TargetController to remove a breakpoint from the target.
*
* @param breakpoint
*/
void removeBreakpoint(TargetBreakpoint breakpoint);
/**
* Requests a pin state update on the target, for a specific pin.
*
* @param variantId
* @param pinDescriptor
* @param pinState
*/
void setPinState(int variantId, TargetPinDescriptor pinDescriptor, TargetPinState pinState);
/**
* Requests a pin state refresh from the TargetController, for a specific target variant.
*
* @param variantId
*/
void requestPinStates(int variantId);
};
}