---
name: Author Input Signals
slug: author-input-signals
category: AI Engineering
description: Author Input Signals creates synthetic waveforms for Simulink inports using createInputDataset. Use it to populate External Inputs or Signal Editor datasets with correct metadata, or to set up function-call and trigger timing.
github: "https://github.com/matlab/simulink-agentic-toolkit/tree/main/skills-catalog/simulink-simulation/authoring-simulink-inputs"
language: HTML
stars: 963
forks: 94
install: "npx degit https://github.com/matlab/simulink-agentic-toolkit/tree/main/skills-catalog/simulink-simulation/authoring-simulink-inputs ~/.claude/skills/authoring-simulink-inputs"
installs_to: ~/.claude/skills/authoring-simulink-inputs
source_path: skills-catalog/simulink-simulation/authoring-simulink-inputs/SKILL.md
collection_size: 24
category_size: 2451
collection_url: "https://dirskills.com/collections/matlab/simulink-agentic-toolkit"
added: 2026-08-21T05:15:17.777Z
last_synced: 2026-08-21T05:15:17.777Z
canonical_url: "https://dirskills.com/skills/author-input-signals"
---

# Author Input Signals

Author Input Signals creates synthetic waveforms for Simulink inports using createInputDataset. Use it to populate External Inputs or Signal Editor datasets with correct metadata, or to set up function-call and trigger timing.

**Install:**

```bash
npx degit https://github.com/matlab/simulink-agentic-toolkit/tree/main/skills-catalog/simulink-simulation/authoring-simulink-inputs ~/.claude/skills/authoring-simulink-inputs
```

## README

# Author Input Signals

Create populated input signal datasets for Simulink models using `createInputDataset` as the scaffold, then populating with meaningful waveforms while preserving all signal metadata.

## When to Use

- User asks to **generate or create synthetic waveforms** (step, ramp, sine, chirp, pulse, noise, constant) for a model's inports
- User wants to **populate a Dataset** created by `createInputDataset` with meaningful signal data
- User needs signals for **Signal Editor** scenarios
- User describes desired **input signal behavior** in natural language (e.g., "ramp from 0 to 10", "sine at 5 Hz")
- User wants **timetable-based input signals** for inports
- User needs to set up **function-call timing** or configure trigger/enable inport signals
- User wants to replace **zero-filled scaffold** data with realistic waveforms

## When NOT to Use

- User wants to **simulate** the model, **run** it, or **plot outputs** — use `simulating-simulink-models` instead. This skill only creates input data; it never runs `sim()` or produces plots.
- User wants to **load, import, or read** data from existing files (CSV, MAT, spreadsheet, .mat workspace) — even if the destination is a model inport. This skill generates *new synthetic waveforms from scratch*; it does not read or convert existing recorded/measured data.

## Output

This skill produces:

1. **MATLAB code** — a local function that generates and returns the Dataset (reproducible, editable, keeps workspace clean)
2. **Dataset variable (`ds`)** — populated `Simulink.SimulationData.Dataset` in the base workspace, ready for simulation
3. **Summary** — brief description of each element: name, data type, waveform shape, and value range

To simulate with the Dataset, follow the `simulating-simulink-models` skill workflow (`SimulationInput` → `setExternalInput` → `sim`).

## Must-Follow Rules

1. **Start from `createInputDataset` — call it exactly once** — never build a Dataset from scratch. Call `createInputDataset` once per model (it triggers update diagram). For multiple datasets, clone the returned scaffold in a loop rather than calling `createInputDataset` again
2. **Preserve metadata from scaffold** — every new timeseries must copy `origEl.DataInfo.Interpolation` and `origEl.DataInfo.Units`. For timetables, copy `origEl.Properties.VariableContinuity`. Omitting these is a bug
3. **Replace elements in place** — for timeseries: `ds{k} = ts`. For timetable: `ds = ds.setElement(k, tt, origEl.Properties.Description)` — never use `addElement`
4. **Respect data types** — use `cast(data, 'like', origEl.Data)` to match any scaffold type (double, single, integer, fixed-point). For boolean inports use `true(size(t))` directly
5. **Set interpolation correctly** — continuous signals (sine, ramp, chirp) use linear; discrete signals (step, pulse, boolean, integer, noise) use zero-order hold. The scaffold's interpolation reflects the inport's `Interpolate` property — preserve it unless the signal nature demands otherwise
6. **Wrap all generation logic in a function** — the only variables left in the base workspace should be the Dataset (and `simIn`/`simOut` if simulating). All intermediate variables (`t`, `dt`, `origEl`, `ts`, `signalData`, `k`) must stay inside function scope
7. **Never destroy user data** — never call `clear`, `clearvars`, `clear all`, or `bdclose all`. The user may have existing variables, models, or figures open. Only add to the workspace, never remove from it

## Workflow

**Determine your entry point.** Do not always start at step 1. Assess what the user already has:

| User's current state | Start at |
|---------------------|----------|
| No existing Dataset or script — starting fresh | Step 1 |
| Has a Dataset variable but it's empty/scaffold (all zeros or placeholder data) | Step 2 |
| Has a Dataset with some signals populated but needs fixes (wrong shape, dtype, interpolation) | Step 2 — inspect the broken element, fix in place |
| Has a working script but wants additional scenarios or signals added | Step 2 or "Creating Multiple Datasets" |
| Has a complete Dataset but simulation fails | Diagnose the error first — often a metadata mismatch (interpolation, dtype, units) fixable in Step 2 |

A **scaffold** is the Dataset returned by `createInputDataset`. It contains one element per inport, pre-filled with correct metadata (data type, interpolation method, units, signal dimensions) but only placeholder time samples (typically 2 zero-valued rows). The workflow replaces this placeholder data with meaningful waveforms while preserving the metadata.

### 1. Create the scaffold (inside a function)

All generation code lives in a local function. The caller invokes the function and receives the populated Dataset:

```matlab
ds = buildInputs('modelName');

function ds = buildInputs(mdl)
    ds = createInputDataset(mdl);
    % — or timetable format —
    % ds = createInputDataset(mdl, 'DatasetSignalFormat', 'timetable');

    stopTime = str2double(get_param(mdl, 'StopTime'));
    dt = 0.01;
    t = (0:dt:stopTime)';

    % ... populate elements (Step 2) ...
end
```

If `createInputDataset` fails (model cannot compile), use `model_read` to inspect the model's inport blocks and ask the user for any type/dimension info that cannot be determined from the model structure.

### 2. Populate each element (inside the same function)

Replace placeholder scaffold data with meaningful signal waveforms while preserving metadata. For each element:

1. Extract the original element (`origEl = ds{k}`)
2. Generate your waveform and cast via `cast(data, 'like', origEl.Data)` — works for all types including fixed-point
3. Create the new timeseries or timetable
4. Copy `DataInfo.Interpolation` and `DataInfo.Units` from `origEl` (timeseries) or `VariableContinuity` from `origEl` (timetable)
5. Replace in place: `ds{k} = ts` (timeseries) or `ds = ds.setElement(k, tt, origEl.Properties.Description)` (timetable)

See [references/signal-patterns.md](references/signal-patterns.md) — "Dataset Assembly" sections — for the complete code patterns.


## Creating Multiple Datasets

Call `createInputDataset` once, then clone the scaffold in a loop inside a function. See [references/dataset-patterns.md](references/dataset-patterns.md) — "Creating Multiple Datasets" section — for the complete pattern.

## Bus Signal Inports

If the model has bus signal inports, see the "Bus Signal Inports" section in [references/dataset-patterns.md](references/dataset-patterns.md).

## Function-Call Inports

If the model has function-call inports, see the "Function-Call Inports" section in [references/dataset-patterns.md](references/dataset-patterns.md).

## Signal Types

See [references/signal-patterns.md](references/signal-patterns.md) for waveform generation code (sine, step, ramp, chirp, pulse, noise, constant, enum).

## Interpolation and Continuity (explicit set — use only when overriding scaffold)

| Signal nature | timeseries | timetable |
|--------------|-----------|-----------|
| Continuous (sine, ramp, chirp) | `tsdata.interpolation('linear')` | `"continuous"` |
| Discrete (step, pulse, boolean) | `tsdata.interpolation('zoh')` | `"step"` |

## Guardrails

| Mistake | Why It's Wrong | Correct Approach |
|---------|---------------|-----------------|
| Using `ones(size(t))` for boolean enable | Creates double; simulation fails with type mismatch | Use `true(size(t))` |
| Ignoring struct fields in bus scaffold | Missing or incorrectly typed bus element causes simulation error | Populate every field in the struct, preserving each field's metadata |
| Treating scaffold data rows as signal width | Scaffold `[2 1]` data means 2 time samples of a scalar, not a 2-element vector | Use `size(origEl.Data, 2)` for signal width — rows are placeholder time samples |
| Enum data fails with "turn off interpolation" | Simulink requires `Interpolate='off'` on inport blocks receiving enum data — even with zoh set on the timeseries | This is a model fix, not a data fix. Use `simIn.setBlockParameter(portPath, 'Interpolate', 'off')` before simulating |

----

Copyright 2026 The MathWorks, Inc.

----