Plots bound signals against simulation time on a multi-channel scope.
The Dashboard Scope block displays one or more bound signals as curves over a rolling time span. It samples the connected signals after every simulation step and refreshes the plot, so signal trends can be watched live while a model runs.
This block declares no input ports.
This block declares no output ports.
These serialized keys are exposed by the block inspector.
This page describes the native runtime behavior observed in the module C++ sources. Declared phases indicate when the simulation engine calls the block.
Code generation: supported for C and Rust.
Manifestmodules/nflow_blocks/libraries/dashboard/library.json
{
"id": "builtin.dashboard",
"title": "Dashboard",
"version": "1.0.0",
"format": "nflow-2",
"metadata": {
"author": "Allan CORNET",
"created": "2026-08-07",
"tool": "Nelson nflow"
},
"comment": "Interactive controls and signal displays",
"license": "LGPL-3.0",
"builtin": true,
"blocks": [
{
"type": "dashboardScope",
"label": "Dashboard Scope",
"icon": "dashboardScope.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 230,
"height": 165,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"TimeSpan": "auto",
"LegendPosition": "Top",
"ScaleAtStop": "on",
"UpdateMode": "Wrap",
"NormalizeYAxis": "off",
"TicksPosition": "Outside",
"TickLabels": "All",
"Grid": "All",
"Border": "on",
"Markers": "off",
"FontColor": [
0,
0,
0
],
"YLimits": [
-3,
3
],
"Colors": []
},
"render": {
"type": "math",
"formula": "Dashboard Scope"
}
},
{
"type": "dashboardDisplay",
"label": "Display",
"icon": "dashboardDisplay.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 180,
"height": 40,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"Format": "short",
"Alignment": "Center",
"Opacity": "1",
"Layout": "Preserve dimensions",
"FormatString": "%d",
"GridColor": [
0.502,
0.502,
0.502
],
"ShowGrid": "on"
},
"render": {
"type": "math",
"formula": "Display"
}
},
{
"type": "dashboardEdit",
"label": "Edit",
"icon": "dashboardEdit.svg",
"phases": [],
"width": 150,
"height": 30,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"Alignment": "Center",
"Opacity": "1"
},
"render": {
"type": "math",
"formula": "Edit"
}
},
{
"type": "dashboardGauge",
"label": "Gauge",
"icon": "dashboardGauge.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 125,
"height": 140,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ScaleColors": [],
"Limits": [
0,
-1,
100
],
"FontColor": [
0,
0,
0
],
"Opacity": "1",
"ScaleDirection": "Clockwise"
},
"render": {
"type": "math",
"formula": "Gauge"
}
},
{
"type": "dashboardHalfGauge",
"label": "Half Gauge",
"icon": "dashboardHalfGauge.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 156,
"height": 108,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ScaleColors": [],
"Limits": [
0,
-1,
100
],
"FontColor": [
0,
0,
0
],
"Opacity": "1",
"ScaleDirection": "Clockwise"
},
"render": {
"type": "math",
"formula": "Half Gauge"
}
},
{
"type": "dashboardKnob",
"label": "Knob",
"icon": "dashboardKnob.svg",
"phases": [],
"width": 110,
"height": 115,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ScaleType": "Linear",
"Limits": [
0,
-1,
100
]
},
"render": {
"type": "math",
"formula": "Knob"
}
},
{
"type": "dashboardLamp",
"label": "Lamp",
"icon": "dashboardLamp.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 65,
"height": 60,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"ColorDefault": [
0.7529411764705882,
0.7529411764705882,
0.7529411764705882
],
"StateColors": [
{
"Value": 0,
"Color": [
0.392156862745098,
0.8313725490196079,
0.07450980392156863
]
}
],
"Opacity": "1"
},
"render": {
"type": "math",
"formula": "Lamp"
}
},
{
"type": "dashboardLinearGauge",
"label": "Linear Gauge",
"icon": "dashboardLinearGauge.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 210,
"height": 90,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ScaleColors": [],
"Limits": [
0,
-1,
100
],
"FontColor": [
0,
0,
0
],
"Opacity": "1",
"ScaleDirection": "Clockwise"
},
"render": {
"type": "math",
"formula": "Linear Gauge"
}
},
{
"type": "dashboardMultiStateImage",
"label": "MultiStateImage",
"icon": "dashboardMultiStateImage.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 190,
"height": 180,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"States": [
{
"State": 0,
"Size": [
0,
0
],
"Image": "",
"Thumbnail": ""
}
],
"DefaultImage": {
"Size": [
0,
0
],
"Image": "",
"Thumbnail": ""
},
"ScaleMode": "Fill with fixed aspect ratio"
},
"render": {
"type": "math",
"formula": "MultiStateImage"
}
},
{
"type": "dashboardPushButton",
"label": "Push Button",
"icon": "dashboardPushButton.svg",
"phases": [],
"width": 91,
"height": 44,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"ButtonText": "Button",
"OnValue": "1",
"Opacity": "1",
"ButtonType": "Momentary",
"Icon": "None",
"CustomIcon": "",
"IconAlignment": "Left",
"IconOnColor": [
0,
0.392156862745098,
0
],
"IconOffColor": [
0,
1,
0
],
"IconColor": "Off"
},
"render": {
"type": "math",
"formula": "Push Button"
}
},
{
"type": "dashboardQuarterGauge",
"label": "Quarter Gauge",
"icon": "dashboardQuarterGauge.svg",
"phases": [
"INIT",
"AFTER_STEP"
],
"width": 140,
"height": 160,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ScaleColors": [],
"Limits": [
0,
-1,
100
],
"FontColor": [
0,
0,
0
],
"Opacity": "1",
"ScaleDirection": "Clockwise"
},
"render": {
"type": "math",
"formula": "Quarter Gauge"
}
},
{
"type": "dashboardRadioButton",
"label": "Radio Button",
"icon": "dashboardRadioButton.svg",
"phases": [],
"width": 135,
"height": 115,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ButtonGroupName": "Group",
"States": [
{
"Value": 0,
"Label": "Label1"
},
{
"Value": 1,
"Label": "Label2"
},
{
"Value": 2,
"Label": "Label3"
}
],
"UseEnumeratedDataType": "off",
"EnumeratedDataType": "",
"Opacity": "1"
},
"render": {
"type": "math",
"formula": "Radio Button"
}
},
{
"type": "dashboardRockerSwitch",
"label": "Rocker Switch",
"icon": "dashboardRockerSwitch.svg",
"phases": [],
"width": 55,
"height": 100,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"States": [
{
"Value": 0,
"Label": "Off"
},
{
"Value": 1,
"Label": "On"
}
]
},
"render": {
"type": "math",
"formula": "Rocker Switch"
}
},
{
"type": "dashboardRotarySwitch",
"label": "Rotary Switch",
"icon": "dashboardRotarySwitch.svg",
"phases": [],
"width": 125,
"height": 100,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"States": [
{
"Value": 0,
"Label": "Off"
},
{
"Value": 1,
"Label": "Low"
},
{
"Value": 2,
"Label": "Medium"
},
{
"Value": 3,
"Label": "High"
}
],
"UseEnumeratedDataType": "off",
"EnumeratedDataType": ""
},
"render": {
"type": "math",
"formula": "Rotary Switch"
}
},
{
"type": "dashboardSlider",
"label": "Slider",
"icon": "dashboardSlider.svg",
"phases": [],
"width": 200,
"height": 90,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"ScaleType": "Linear",
"Limits": [
0,
-1,
100
]
},
"render": {
"type": "math",
"formula": "Slider"
}
},
{
"type": "dashboardSliderSwitch",
"label": "Slider Switch",
"icon": "dashboardSliderSwitch.svg",
"phases": [],
"width": 120,
"height": 45,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"States": [
{
"Value": 0,
"Label": "Off"
},
{
"Value": 1,
"Label": "On"
}
]
},
"render": {
"type": "math",
"formula": "Slider Switch"
}
},
{
"type": "dashboardToggleSwitch",
"label": "Toggle Switch",
"icon": "dashboardToggleSwitch.svg",
"phases": [],
"width": 55,
"height": 100,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "on",
"States": [
{
"Value": 0,
"Label": "Off"
},
{
"Value": 1,
"Label": "On"
}
]
},
"render": {
"type": "math",
"formula": "Toggle Switch"
}
},
{
"type": "dashboardCallbackButton",
"label": "Callback Button",
"icon": "dashboardCallbackButton.svg",
"phases": [],
"width": 110,
"height": 35,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Top",
"Binding": null,
"ShowInitialText": "off",
"ButtonText": "Callback Button",
"ButtonType": "Momentary",
"ClickFcn": "",
"OnValue": 1,
"PressDelay": "500",
"PressFcn": "",
"RepeatInterval": "0",
"AutoActivate": true,
"fixedAspectRatio": "off"
},
"render": {
"type": "math",
"formula": "Callback Button"
}
},
{
"type": "dashboardCheckBox",
"label": "Check Box",
"icon": "dashboardCheckBox.svg",
"phases": [],
"width": 135,
"height": 30,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"Label": "Label",
"Values": [
0,
1
],
"Opacity": "1"
},
"render": {
"type": "math",
"formula": "Check Box"
}
},
{
"type": "dashboardComboBox",
"label": "Combo Box",
"icon": "dashboardComboBox.svg",
"phases": [],
"width": 160,
"height": 25,
"inputs": [],
"outputs": [],
"defaultParams": {
"LabelPosition": "Hide",
"Binding": null,
"ShowInitialText": "on",
"States": [
{
"Value": 0,
"Label": "Label1"
},
{
"Value": 1,
"Label": "Label2"
},
{
"Value": 2,
"Label": "Label3"
}
],
"UseEnumeratedDataType": "off",
"EnumeratedDataType": "",
"Opacity": "1"
},
"render": {
"type": "math",
"formula": "Combo Box"
}
}
]
}
Runtimemodules/nflow_blocks/src/cpp/DashboardHandlers.cpp
//=============================================================================
// Copyright (c) 2026-present Allan CORNET (Nelson)
//=============================================================================
// This file is part of Nelson.
//=============================================================================
// LICENCE_BLOCK_BEGIN
// SPDX-License-Identifier: LGPL-3.0-or-later
// LICENCE_BLOCK_END
//=============================================================================
#include "BlockRegistry.hpp"
#include "SimEngineTypes.hpp"
#include <algorithm>
//=============================================================================
namespace Nelson::NFlow {
//=============================================================================
static bool
dashboardPath(const nlohmann::json& binding, std::vector<std::string>& path)
{
path.clear();
if (!binding.is_object() || !binding.contains("blockPath")) {
return false;
}
const auto& value = binding["blockPath"];
if (value.is_string()) {
const std::string id = value.get<std::string>();
if (!id.empty()) {
path.push_back(id);
}
} else if (value.is_array()) {
for (const auto& item : value) {
if (item.is_string() && !item.get<std::string>().empty()) {
path.push_back(item.get<std::string>());
}
}
}
return !path.empty();
}
//=============================================================================
static bool
readSubsystemOutput(const BlockState::SubsystemState& subsystem,
const std::vector<std::string>& path, size_t pathIndex, int port, std::vector<double>& values,
std::vector<double>& valuesImag, std::vector<long long>& valuesI64, int& exactType)
{
if (pathIndex >= path.size()) {
return false;
}
auto found = subsystem.nameToId.find(path[pathIndex]);
if (found == subsystem.nameToId.end()) {
return false;
}
const BlockId nid = found->second;
if (nid < 0 || nid >= static_cast<BlockId>(subsystem.blocks.size())
|| nid >= static_cast<BlockId>(subsystem.blockStateVec.size())) {
return false;
}
if (pathIndex + 1 < path.size()) {
const auto& nested = subsystem.blockStateVec[nid].subsystem;
return nested
&& readSubsystemOutput(
*nested, path, pathIndex + 1, port, values, valuesImag, valuesI64, exactType);
}
const Block& source = subsystem.blocks[nid];
if (port < 0 || port >= source.outputs) {
return false;
}
int offset = -1;
int width = 1;
exactType = static_cast<int>(SigType::Double);
if (!subsystem.portBase.empty() && nid < static_cast<BlockId>(subsystem.portBase.size())) {
const int gpi = subsystem.portBase[nid] + port;
if (gpi >= 0 && gpi < static_cast<int>(subsystem.sigs.size())) {
const PortSig& sig = subsystem.sigs[gpi];
offset = sig.offset;
width = std::max(1, sig.width());
exactType = static_cast<int>(sig.type);
if (sig.isComplex && offset >= 0
&& offset + width <= static_cast<int>(subsystem.outputsImagVec.size())) {
valuesImag.assign(subsystem.outputsImagVec.begin() + offset,
subsystem.outputsImagVec.begin() + offset + width);
}
if (portUsesI64(sig) && offset >= 0
&& offset + width <= static_cast<int>(subsystem.outputsI64Vec.size())) {
valuesI64.assign(subsystem.outputsI64Vec.begin() + offset,
subsystem.outputsI64Vec.begin() + offset + width);
}
}
}
if (offset < 0 && nid < static_cast<BlockId>(subsystem.outputBase.size())) {
offset = subsystem.outputBase[nid] + port;
}
if (offset < 0 || offset + width > static_cast<int>(subsystem.outputsVec.size())) {
return false;
}
values.assign(
subsystem.outputsVec.begin() + offset, subsystem.outputsVec.begin() + offset + width);
return true;
}
//=============================================================================
static bool
readDashboardSignal(SimCtx& ctx, const nlohmann::json& binding, std::vector<double>& values,
std::vector<double>& valuesImag, std::vector<long long>& valuesI64, int& exactType)
{
if (!binding.is_object() || binding.value("kind", std::string()) != "signal") {
return false;
}
std::vector<std::string> path;
if (!dashboardPath(binding, path)) {
return false;
}
auto found = ctx.nameToId.find(path.front());
if (found == ctx.nameToId.end()) {
return false;
}
const BlockId nid = found->second;
const int port = std::max(1, binding.value("outputPortIndex", 1)) - 1;
if (nid < 0 || nid >= static_cast<BlockId>(ctx.blocks.size())
|| port >= ctx.blocks[nid].outputs) {
return false;
}
if (path.size() > 1) {
const auto& subsystem = ctx.blockState[nid].subsystem;
return subsystem
&& readSubsystemOutput(
*subsystem, path, 1, port, values, valuesImag, valuesI64, exactType);
}
const int offset = slotOf(ctx, nid, port);
const int width = outputWidth(ctx, nid, port);
if (offset < 0 || width <= 0 || offset + width > static_cast<int>(ctx.outputs.size())) {
return false;
}
values.assign(ctx.outputs.begin() + offset, ctx.outputs.begin() + offset + width);
const PortSig* signal = portSigOf(ctx, nid, port);
exactType = static_cast<int>(signal ? signal->type : SigType::Double);
if (signal && signal->isComplex && ctx.outputsImag
&& offset + width <= static_cast<int>(ctx.outputsImag->size())) {
valuesImag.assign(
ctx.outputsImag->begin() + offset, ctx.outputsImag->begin() + offset + width);
}
if (signal && portUsesI64(*signal) && ctx.outputsI64
&& offset + width <= static_cast<int>(ctx.outputsI64->size())) {
valuesI64.assign(
ctx.outputsI64->begin() + offset, ctx.outputsI64->begin() + offset + width);
}
return true;
}
//=============================================================================
static bool
handleDashboardObserver(SimCtx& ctx, const Block& block, Phase phase)
{
BlockState& state = getState(ctx, block.nid);
if (phase == Phase::INIT) {
state.scalar = 0.0;
state.scalar2 = 0.0;
state.displayValues.clear();
state.displayValuesImag.clear();
state.displayValuesI64.clear();
state.scopeSeries.clear();
state.scopeSeriesImag.clear();
state.scopeSeriesI64.clear();
state.xSeries.clear();
state.scopeExactType = static_cast<int>(SigType::Double);
state.dashboardTouched = false;
state.dashboardError.clear();
return false;
}
if (phase != Phase::AFTER_STEP) {
return false;
}
const nlohmann::json binding = block.params.value("Binding", nlohmann::json());
std::vector<double> values;
std::vector<double> valuesImag;
std::vector<long long> valuesI64;
int exactType = static_cast<int>(SigType::Double);
if (!readDashboardSignal(ctx, binding, values, valuesImag, valuesI64, exactType)) {
state.scalar2 = 0.0;
return false;
}
state.scalar2 = 1.0;
state.scopeExactType = exactType;
state.scalar = values.empty() ? 0.0 : values.front();
state.displayValues = values;
state.displayValuesImag = valuesImag;
state.displayValuesI64 = valuesI64;
state.dashboardTouched = true;
if (block.type == "dashboardScope") {
if (state.scopeSeries.size() != values.size()) {
state.scopeSeries.assign(values.size(), std::vector<double> {});
}
if (!valuesImag.empty() && state.scopeSeriesImag.size() != valuesImag.size()) {
state.scopeSeriesImag.assign(valuesImag.size(), std::vector<double> {});
}
if (!valuesI64.empty() && state.scopeSeriesI64.size() != valuesI64.size()) {
state.scopeSeriesI64.assign(valuesI64.size(), std::vector<long long> {});
}
for (size_t i = 0; i < values.size(); ++i) {
state.scopeSeries[i].push_back(values[i]);
}
for (size_t i = 0; i < valuesImag.size(); ++i) {
state.scopeSeriesImag[i].push_back(valuesImag[i]);
}
for (size_t i = 0; i < valuesI64.size(); ++i) {
state.scopeSeriesI64[i].push_back(valuesI64[i]);
}
state.xSeries.push_back(ctx.t);
}
return false;
}
//=============================================================================
static bool
handleDashboardControl(SimCtx&, const Block&, Phase)
{
return false;
}
//=============================================================================
void
registerDashboardHandlers(BlockRegistry& registry)
{
const char* observers[] = { "dashboardScope", "dashboardDisplay", "dashboardGauge",
"dashboardHalfGauge", "dashboardQuarterGauge", "dashboardLinearGauge", "dashboardLamp",
"dashboardMultiStateImage" };
for (const char* type : observers) {
registry.registerHandler(
type, handleDashboardObserver, { Phase::INIT, Phase::AFTER_STEP }, "builtin.dashboard");
}
const char* controls[] = { "dashboardEdit", "dashboardKnob", "dashboardSlider",
"dashboardPushButton", "dashboardRotarySwitch", "dashboardRadioButton", "dashboardComboBox",
"dashboardCheckBox", "dashboardRockerSwitch", "dashboardSliderSwitch",
"dashboardToggleSwitch", "dashboardCallbackButton" };
BlockMetadata metadata;
metadata.interactive = true;
for (const char* type : controls) {
registry.registerHandler(type, handleDashboardControl, {}, "builtin.dashboard", metadata);
}
}
//=============================================================================
} // namespace Nelson::NFlow
//=============================================================================
