goran-mahovlic
/
eez-flow-template-stm32l496g-disco
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14 Commits
1 Branch
0 Tags
5.8 MiB
 
 
 
 
 
 
Branch: main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
eez-flow-template-stm32l496.../Middlewares/eez/flow/debugger.cpp

760 lines
21 KiB
Raw Permalink Blame History

/*
* EEZ Modular Firmware
* Copyright (C) 2021-present, Envox d.o.o.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <inttypes.h>
#include <eez/core/debug.h>
#include <eez/core/os.h>
#include <eez/gui/gui.h>
#include <eez/flow/flow.h>
#include <eez/flow/private.h>
#include <eez/flow/debugger.h>
#include <eez/flow/hooks.h>
namespace eez {
namespace flow {
enum MessagesToDebugger {
MESSAGE_TO_DEBUGGER_STATE_CHANGED, // STATE
MESSAGE_TO_DEBUGGER_ADD_TO_QUEUE, // FLOW_STATE_INDEX, SOURCE_COMPONENT_INDEX, SOURCE_OUTPUT_INDEX, TARGET_COMPONENT_INDEX, TARGET_INPUT_INDEX, FREE_MEMORT, ALLOC_MEMORY
MESSAGE_TO_DEBUGGER_REMOVE_FROM_QUEUE, // no params
MESSAGE_TO_DEBUGGER_GLOBAL_VARIABLE_INIT, // GLOBAL_VARIABLE_INDEX, VALUE_ADDR, VALUE
MESSAGE_TO_DEBUGGER_LOCAL_VARIABLE_INIT, // FLOW_STATE_INDEX, LOCAL_VARIABLE_INDEX, VALUE_ADDR, VALUE
MESSAGE_TO_DEBUGGER_COMPONENT_INPUT_INIT, // FLOW_STATE_INDEX, COMPONENT_INPUT_INDEX, VALUE_ADDR, VALUE
MESSAGE_TO_DEBUGGER_VALUE_CHANGED, // VALUE_ADDR, VALUE
MESSAGE_TO_DEBUGGER_FLOW_STATE_CREATED, // FLOW_STATE_INDEX, FLOW_INDEX, PARENT_FLOW_STATE_INDEX (-1 - NO PARENT), PARENT_COMPONENT_INDEX (-1 - NO PARENT COMPONENT)
MESSAGE_TO_DEBUGGER_FLOW_STATE_TIMELINE_CHANGED, // FLOW_STATE_INDEX, TIMELINE_POSITION
MESSAGE_TO_DEBUGGER_FLOW_STATE_DESTROYED, // FLOW_STATE_INDEX
MESSAGE_TO_DEBUGGER_FLOW_STATE_ERROR, // FLOW_STATE_INDEX, COMPONENT_INDEX, ERROR_MESSAGE
MESSAGE_TO_DEBUGGER_LOG, // LOG_ITEM_TYPE, FLOW_STATE_INDEX, COMPONENT_INDEX, MESSAGE
MESSAGE_TO_DEBUGGER_PAGE_CHANGED, // PAGE_ID
MESSAGE_TO_DEBUGGER_COMPONENT_EXECUTION_STATE_CHANGED, // FLOW_STATE_INDEX, COMPONENT_INDEX, STATE
MESSAGE_TO_DEBUGGER_COMPONENT_ASYNC_STATE_CHANGED // FLOW_STATE_INDEX, COMPONENT_INDEX, STATE
};
enum MessagesFromDebugger {
MESSAGE_FROM_DEBUGGER_RESUME, // no params
MESSAGE_FROM_DEBUGGER_PAUSE, // no params
MESSAGE_FROM_DEBUGGER_SINGLE_STEP, // no params
MESSAGE_FROM_DEBUGGER_ADD_BREAKPOINT, // FLOW_INDEX, COMPONENT_INDEX
MESSAGE_FROM_DEBUGGER_REMOVE_BREAKPOINT, // FLOW_INDEX, COMPONENT_INDEX
MESSAGE_FROM_DEBUGGER_ENABLE_BREAKPOINT, // FLOW_INDEX, COMPONENT_INDEX
MESSAGE_FROM_DEBUGGER_DISABLE_BREAKPOINT, // FLOW_INDEX, COMPONENT_INDEX
MESSAGE_FROM_DEBUGGER_MODE // MODE (0:RUN | 1:DEBUG)
};
enum LogItemType {
LOG_ITEM_TYPE_FATAL,
LOG_ITEM_TYPE_ERROR,
LOG_ITEM_TYPE_WARNING ,
LOG_ITEM_TYPE_SCPI,
LOG_ITEM_TYPE_INFO,
LOG_ITEM_TYPE_DEBUG
};
enum DebuggerState {
DEBUGGER_STATE_RESUMED,
DEBUGGER_STATE_PAUSED,
DEBUGGER_STATE_SINGLE_STEP,
DEBUGGER_STATE_STOPPED,
};
bool g_debuggerIsConnected;
static DebuggerState g_debuggerState;
static bool g_skipNextBreakpoint;
static char g_inputFromDebugger[64];
static unsigned g_inputFromDebuggerPosition;
int g_debuggerMode = DEBUGGER_MODE_RUN;
////////////////////////////////////////////////////////////////////////////////
static void setDebuggerState(DebuggerState newState) {
if (newState != g_debuggerState) {
g_debuggerState = newState;
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\n",
MESSAGE_TO_DEBUGGER_STATE_CHANGED,
g_debuggerState
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
}
////////////////////////////////////////////////////////////////////////////////
void onDebuggerClientConnected() {
g_debuggerIsConnected = true;
g_skipNextBreakpoint = false;
g_inputFromDebuggerPosition = 0;
setDebuggerState(DEBUGGER_STATE_PAUSED);
}
void onDebuggerClientDisconnected() {
g_debuggerIsConnected = false;
setDebuggerState(DEBUGGER_STATE_RESUMED);
}
////////////////////////////////////////////////////////////////////////////////
void processDebuggerInput(char *buffer, uint32_t length) {
for (uint32_t i = 0; i < length; i++) {
if (buffer[i] == '\n') {
int messageFromDebugger = g_inputFromDebugger[0] - '0';
if (messageFromDebugger == MESSAGE_FROM_DEBUGGER_RESUME) {
setDebuggerState(DEBUGGER_STATE_RESUMED);
} else if (messageFromDebugger == MESSAGE_FROM_DEBUGGER_PAUSE) {
setDebuggerState(DEBUGGER_STATE_PAUSED);
} else if (messageFromDebugger == MESSAGE_FROM_DEBUGGER_SINGLE_STEP) {
setDebuggerState(DEBUGGER_STATE_SINGLE_STEP);
} else if (
messageFromDebugger >= MESSAGE_FROM_DEBUGGER_ADD_BREAKPOINT &&
messageFromDebugger <= MESSAGE_FROM_DEBUGGER_DISABLE_BREAKPOINT
) {
char *p;
auto flowIndex = (uint32_t)strtol(g_inputFromDebugger + 2, &p, 10);
auto componentIndex = (uint32_t)strtol(p + 1, nullptr, 10);
auto assets = g_firstFlowState->assets;
auto flowDefinition = static_cast<FlowDefinition *>(assets->flowDefinition);
if (flowIndex >= 0 && flowIndex < flowDefinition->flows.count) {
auto flow = flowDefinition->flows[flowIndex];
if (componentIndex >= 0 && componentIndex < flow->components.count) {
auto component = flow->components[componentIndex];
component->breakpoint = messageFromDebugger == MESSAGE_FROM_DEBUGGER_ADD_BREAKPOINT ||
messageFromDebugger == MESSAGE_FROM_DEBUGGER_ENABLE_BREAKPOINT ? 1 : 0;
} else {
ErrorTrace("Invalid breakpoint component index\n");
}
} else {
ErrorTrace("Invalid breakpoint flow index\n");
}
} else if (messageFromDebugger == MESSAGE_FROM_DEBUGGER_MODE) {
g_debuggerMode = strtol(g_inputFromDebugger + 2, nullptr, 10);
gui::refreshScreen();
}
g_inputFromDebuggerPosition = 0;
} else {
if (g_inputFromDebuggerPosition < sizeof(g_inputFromDebugger)) {
g_inputFromDebugger[g_inputFromDebuggerPosition++] = buffer[i];
} else if (g_inputFromDebuggerPosition == sizeof(g_inputFromDebugger)) {
ErrorTrace("Input from debugger buffer overflow\n");
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
bool canExecuteStep(FlowState *&flowState, unsigned &componentIndex) {
if (!g_debuggerIsConnected) {
return true;
}
if (g_debuggerState == DEBUGGER_STATE_PAUSED) {
return false;
}
if (g_debuggerState == DEBUGGER_STATE_SINGLE_STEP) {
g_skipNextBreakpoint = false;
setDebuggerState(DEBUGGER_STATE_PAUSED);
return true;
}
// g_debuggerState == DEBUGGER_STATE_RESUMED
if (g_skipNextBreakpoint) {
g_skipNextBreakpoint = false;
} else {
auto component = flowState->flow->components[componentIndex];
if (component->breakpoint) {
g_skipNextBreakpoint = true;
setDebuggerState(DEBUGGER_STATE_PAUSED);
return false;
}
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
#if defined(__EMSCRIPTEN__)
char outputBuffer[1024 * 1024];
#else
char outputBuffer[64];
#endif
int outputBufferPosition = 0;
#define WRITE_TO_OUTPUT_BUFFER(ch) \
outputBuffer[outputBufferPosition++] = ch; \
if (outputBufferPosition == sizeof(outputBuffer)) { \
writeDebuggerBufferHook(outputBuffer, outputBufferPosition); \
outputBufferPosition = 0; \
}
#define FLUSH_OUTPUT_BUFFER() \
if (outputBufferPosition > 0) { \
writeDebuggerBufferHook(outputBuffer, outputBufferPosition); \
outputBufferPosition = 0; \
}
void writeValueAddr(const void *pValue) {
char tmpStr[32];
snprintf(tmpStr, sizeof(tmpStr), "%p", pValue);
auto len = strlen(tmpStr);
for (size_t i = 0; i < len; i++) {
WRITE_TO_OUTPUT_BUFFER(tmpStr[i]);
}
}
void writeString(const char *str) {
WRITE_TO_OUTPUT_BUFFER('"');
for (const char *p = str; *p; p++) {
if (*p == '"') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('"');
} else if (*p == '\t') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('t');
} else if (*p == '\n') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('n');
} else {
WRITE_TO_OUTPUT_BUFFER(*p);
}
}
WRITE_TO_OUTPUT_BUFFER('"');
WRITE_TO_OUTPUT_BUFFER('\n');
FLUSH_OUTPUT_BUFFER();
}
void writeArrayType(uint32_t arrayType) {
char tmpStr[32];
snprintf(tmpStr, sizeof(tmpStr), "%x", (int)arrayType);
auto len = strlen(tmpStr);
for (size_t i = 0; i < len; i++) {
WRITE_TO_OUTPUT_BUFFER(tmpStr[i]);
}
}
void writeArray(const ArrayValue *arrayValue) {
WRITE_TO_OUTPUT_BUFFER('{');
writeValueAddr(arrayValue);
WRITE_TO_OUTPUT_BUFFER(',');
writeArrayType(arrayValue->arrayType);
for (uint32_t i = 0; i < arrayValue->arraySize; i++) {
WRITE_TO_OUTPUT_BUFFER(',');
writeValueAddr(&arrayValue->values[i]);
}
WRITE_TO_OUTPUT_BUFFER('}');
WRITE_TO_OUTPUT_BUFFER('\n');
FLUSH_OUTPUT_BUFFER();
for (uint32_t i = 0; i < arrayValue->arraySize; i++) {
onValueChanged(&arrayValue->values[i]);
}
}
void writeHex(char *dst, uint8_t *src, size_t srcLength) {
*dst++ = 'H';
for (size_t i = 0; i < srcLength; i++) {
*dst++ = toHexDigit(src[i] / 16);
*dst++ = toHexDigit(src[i] % 16);
}
*dst++ = 0;
}
void writeValue(const Value &value) {
char tempStr[64];
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4474)
#endif
switch (value.getType()) {
case VALUE_TYPE_UNDEFINED:
stringCopy(tempStr, sizeof(tempStr) - 1, "undefined\n");
break;
case VALUE_TYPE_NULL:
stringCopy(tempStr, sizeof(tempStr) - 1, "null\n");
break;
case VALUE_TYPE_BOOLEAN:
stringCopy(tempStr, sizeof(tempStr) - 1, value.getBoolean() ? "true" : "false");
break;
case VALUE_TYPE_INT8:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRId8 "", value.int8Value);
break;
case VALUE_TYPE_UINT8:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRIu8 "", value.uint8Value);
break;
case VALUE_TYPE_INT16:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRId16 "", value.int16Value);
break;
case VALUE_TYPE_UINT16:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRIu16 "", value.uint16Value);
break;
case VALUE_TYPE_INT32:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRId32 "", value.int32Value);
break;
case VALUE_TYPE_UINT32:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRIu32 "", value.uint32Value);
break;
case VALUE_TYPE_INT64:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRId64 "", value.int64Value);
break;
case VALUE_TYPE_UINT64:
snprintf(tempStr, sizeof(tempStr) - 1, "%" PRIu64 "", value.uint64Value);
break;
case VALUE_TYPE_DOUBLE:
writeHex(tempStr, (uint8_t *)&value.doubleValue, sizeof(double));
break;
case VALUE_TYPE_FLOAT:
writeHex(tempStr, (uint8_t *)&value.floatValue, sizeof(float));
break;
case VALUE_TYPE_STRING:
case VALUE_TYPE_STRING_REF:
writeString(value.getString());
return;
case VALUE_TYPE_ARRAY:
case VALUE_TYPE_ARRAY_REF:
writeArray(value.getArray());
return;
case VALUE_TYPE_BLOB_REF:
snprintf(tempStr, sizeof(tempStr) - 1, "@%d", (int)((BlobRef *)value.refValue)->len);
break;
case VALUE_TYPE_STREAM:
snprintf(tempStr, sizeof(tempStr) - 1, ">%d", (int)(value.int32Value));
break;
case VALUE_TYPE_DATE:
tempStr[0] = '!';
writeHex(tempStr + 1, (uint8_t *)&value.doubleValue, sizeof(double));
break;
default:
tempStr[0] = 0;
break;
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
stringAppendString(tempStr, sizeof(tempStr), "\n");
writeDebuggerBufferHook(tempStr, strlen(tempStr));
}
////////////////////////////////////////////////////////////////////////////////
void onStarted(Assets *assets) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
auto flowDefinition = static_cast<FlowDefinition *>(assets->flowDefinition);
for (uint32_t i = 0; i < flowDefinition->globalVariables.count; i++) {
auto pValue = flowDefinition->globalVariables[i];
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%p\t",
MESSAGE_TO_DEBUGGER_GLOBAL_VARIABLE_INIT,
(int)i,
(const void *)pValue
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeValue(*pValue);
}
}
}
void onStopped() {
setDebuggerState(DEBUGGER_STATE_STOPPED);
}
void onAddToQueue(FlowState *flowState, int sourceComponentIndex, int sourceOutputIndex, unsigned targetComponentIndex, int targetInputIndex) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
uint32_t free;
uint32_t alloc;
getAllocInfo(free, alloc);
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
MESSAGE_TO_DEBUGGER_ADD_TO_QUEUE,
(int)flowState->flowStateIndex,
sourceComponentIndex,
sourceOutputIndex,
targetComponentIndex,
targetInputIndex,
(int)free,
(int)ALLOC_BUFFER_SIZE
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
void onRemoveFromQueue() {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\n",
MESSAGE_TO_DEBUGGER_REMOVE_FROM_QUEUE
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
void onValueChanged(const Value *pValue) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%p\t",
MESSAGE_TO_DEBUGGER_VALUE_CHANGED,
(const void *)pValue
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeValue(*pValue);
}
}
void onFlowStateCreated(FlowState *flowState) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\t%d\n",
MESSAGE_TO_DEBUGGER_FLOW_STATE_CREATED,
(int)flowState->flowStateIndex,
flowState->flowIndex,
(int)(flowState->parentFlowState ? flowState->parentFlowState->flowStateIndex : -1),
flowState->parentComponentIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
auto flow = flowState->flow;
for (uint32_t i = 0; i < flow->localVariables.count; i++) {
auto pValue = &flowState->values[flow->componentInputs.count + i];
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%p\t",
MESSAGE_TO_DEBUGGER_LOCAL_VARIABLE_INIT,
(int)flowState->flowStateIndex,
(int)i,
(const void *)pValue
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeValue(*pValue);
}
for (uint32_t i = 0; i < flow->componentInputs.count; i++) {
//auto &input = flow->componentInputs[i];
//if (!(input & COMPONENT_INPUT_FLAG_IS_SEQ_INPUT)) {
auto pValue = &flowState->values[i];
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%p\t",
MESSAGE_TO_DEBUGGER_COMPONENT_INPUT_INIT,
(int)flowState->flowStateIndex,
(int)i,
(const void *)pValue
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeValue(*pValue);
//}
}
}
}
void onFlowStateDestroyed(FlowState *flowState) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\n",
MESSAGE_TO_DEBUGGER_FLOW_STATE_DESTROYED,
(int)flowState->flowStateIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
void onFlowStateTimelineChanged(FlowState *flowState) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%g\n",
MESSAGE_TO_DEBUGGER_FLOW_STATE_TIMELINE_CHANGED,
(int)flowState->flowStateIndex,
flowState->timelinePosition
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
void onFlowError(FlowState *flowState, int componentIndex, const char *errorMessage) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t",
MESSAGE_TO_DEBUGGER_FLOW_STATE_ERROR,
(int)flowState->flowStateIndex,
componentIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeString(errorMessage);
}
}
void onComponentExecutionStateChanged(FlowState *flowState, int componentIndex) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\n",
MESSAGE_TO_DEBUGGER_COMPONENT_EXECUTION_STATE_CHANGED,
(int)flowState->flowStateIndex,
componentIndex,
flowState->componenentExecutionStates[componentIndex] ? 1 : 0
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
void onComponentAsyncStateChanged(FlowState *flowState, int componentIndex) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\n",
MESSAGE_TO_DEBUGGER_COMPONENT_ASYNC_STATE_CHANGED,
(int)flowState->flowStateIndex,
componentIndex,
flowState->componenentAsyncStates[componentIndex] ? 1 : 0
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
void writeLogMessage(const char *str) {
for (const char *p = str; *p; p++) {
if (*p == '\t') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('t');
} if (*p == '\n') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('n');
} else {
WRITE_TO_OUTPUT_BUFFER(*p);
}
}
WRITE_TO_OUTPUT_BUFFER('\n');
FLUSH_OUTPUT_BUFFER();
}
void writeLogMessage(const char *str, size_t len) {
for (size_t i = 0; i < len; i++) {
if (str[i] == '\t') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('t');
} if (str[i] == '\n') {
WRITE_TO_OUTPUT_BUFFER('\\');
WRITE_TO_OUTPUT_BUFFER('n');
} else {
WRITE_TO_OUTPUT_BUFFER(str[i]);
}
}
WRITE_TO_OUTPUT_BUFFER('\n');
FLUSH_OUTPUT_BUFFER();
}
void logInfo(FlowState *flowState, unsigned componentIndex, const char *message) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\t",
MESSAGE_TO_DEBUGGER_LOG,
LOG_ITEM_TYPE_INFO,
(int)flowState->flowStateIndex,
componentIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeLogMessage(message);
}
}
void logScpiCommand(FlowState *flowState, unsigned componentIndex, const char *cmd) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\tSCPI COMMAND: ",
MESSAGE_TO_DEBUGGER_LOG,
LOG_ITEM_TYPE_SCPI,
(int)flowState->flowStateIndex,
componentIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeLogMessage(cmd);
}
}
void logScpiQuery(FlowState *flowState, unsigned componentIndex, const char *query) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\t%d\t%d\tSCPI QUERY: ",
MESSAGE_TO_DEBUGGER_LOG,
LOG_ITEM_TYPE_SCPI,
(int)flowState->flowStateIndex,
componentIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeLogMessage(query);
}
}
void logScpiQueryResult(FlowState *flowState, unsigned componentIndex, const char *resultText, size_t resultTextLen) {
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer) - 1, "%d\t%d\t%d\t%d\tSCPI QUERY RESULT: ",
MESSAGE_TO_DEBUGGER_LOG,
LOG_ITEM_TYPE_SCPI,
(int)flowState->flowStateIndex,
componentIndex
);
writeDebuggerBufferHook(buffer, strlen(buffer));
writeLogMessage(resultText, resultTextLen);
}
}
void onPageChanged(int previousPageId, int activePageId) {
if (flow::isFlowStopped()) {
return;
}
if (previousPageId == activePageId) {
return;
}
if (previousPageId > 0 && previousPageId < FIRST_INTERNAL_PAGE_ID) {
auto flowState = getFlowState(g_mainAssets, previousPageId - 1, WidgetCursor());
if (flowState) {
onEvent(flowState, FLOW_EVENT_CLOSE_PAGE);
}
} else if (previousPageId < 0) {
auto flowState = getFlowState(g_externalAssets, -previousPageId - 1, WidgetCursor());
if (flowState) {
onEvent(flowState, FLOW_EVENT_CLOSE_PAGE);
}
}
if (activePageId > 0 && activePageId < FIRST_INTERNAL_PAGE_ID) {
auto flowState = getFlowState(g_mainAssets, activePageId - 1, WidgetCursor());
if (flowState) {
onEvent(flowState, FLOW_EVENT_OPEN_PAGE);
}
} else if (activePageId < 0) {
auto flowState = getFlowState(g_externalAssets, -activePageId - 1, WidgetCursor());
if (flowState) {
onEvent(flowState, FLOW_EVENT_OPEN_PAGE);
}
}
if (g_debuggerIsConnected) {
startToDebuggerMessageHook();
char buffer[256];
snprintf(buffer, sizeof(buffer), "%d\t%d\n",
MESSAGE_TO_DEBUGGER_PAGE_CHANGED,
activePageId
);
writeDebuggerBufferHook(buffer, strlen(buffer));
}
}
} // namespace flow
} // namespace eez