simulink-configure-code-interfaces skill
Configure how Simulink model elements are represented in generated C or C++ code through storage classes, function mapping, and interface settings.
- GitHub stars
- 1,345
- Files
- 6
- Last commit
- Nov 11, 2026
- License
- See LICENSE
- Allowed tools
- —
What does the simulink-configure-code-interfaces skill do?
simulink-configure-code-interfaces is an agent skill. Configure how Simulink model elements are represented in generated C or C++ code through storage classes, function mapping, and interface settings.
Summary generated from the skill's SKILL.md.
About the simulink-configure-code-interfaces skill
Engineers managing Simulink models can use this skill to define exactly how model elements appear in generated C or C++ code. It allows for precise control over the names, types, and placement of variables and functions, such as making a model parameter a tunable global extern variable. The tool supports configuring storage classes for signals, states, and parameters, as well as managing function mapping for entry-points and algorithms.
When working with Embedded Coder and ERT system target files, the skill enables advanced interface configurations including deployment types like Component or Subcomponent, and the setup of service interfaces for client-server or sender-receiver patterns. It also facilitates linking and managing Embedded Coder dictionaries to maintain organized data entries. While basic storage class settings work with GRT models using a Simulink Coder license, full interface and service configuration requires an Embedded Coder license and an ERT-based target file.
What an agent can do with it
- 1Map model elements to specific code variablesConfigure a model parameter to be represented as a tunable global extern variable in the generated C code.
- 2Define custom function names for algorithmsSet the specific name for a generated startup routine to ensure it matches project requirements.
- 3Set up service interface patternsConfigure the model to use a client-server interface pattern for communication.
- 4Manage Embedded Coder dictionariesLink a shared Embedded Coder dictionary to a model to manage data entries.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the simulink-configure-code-interfaces skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the simulink-configure-code-interfaces skill in Claude Code
~/.claude/skills/simulink-configure-code-interfaces/SKILL.md
$ npx degit matlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces ~/.claude/skills/simulink-configure-code-interfacesInstall the simulink-configure-code-interfaces skill in Claude Code (project)
.claude/skills/simulink-configure-code-interfaces/SKILL.md
$ npx degit matlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces .claude/skills/simulink-configure-code-interfacesInstall the simulink-configure-code-interfaces skill in Codex
~/.agents/skills/simulink-configure-code-interfaces/SKILL.md
$ npx degit matlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces ~/.agents/skills/simulink-configure-code-interfacesInstall the simulink-configure-code-interfaces skill in Gemini CLI
~/.gemini/skills/simulink-configure-code-interfaces/SKILL.md
$ npx degit matlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces ~/.gemini/skills/simulink-configure-code-interfacesInstall the simulink-configure-code-interfaces skill in Claude.ai
npx degit matlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces simulink-configure-code-interfaces && zip -r simulink-configure-code-interfaces.zip simulink-configure-code-interfaces # claude.ai → Customize → Skills → + → Create skill → Upload a skill → simulink-configure-code-interfaces.zip
Automated checks
Ran Nov 15, 2026Full report →Not verified yet. A skill needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablematlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces is public and reachablegithub.com/matlab/simulink-agentic-toolkit/tree/HEAD/skills- ↗Pass
- Open source license (OSI)License named in a file, not as an SPDX idNot checked
- Commit or release in the last yearLast commit 2026-11-11github.com/matlab/simulink-agentic-toolkit/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/matlab/simulink-agentic-toolkit/blob/HEAD/skills- ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/matlab/simulink-agentic-toolkit/blob/HEAD/skills- ↗Pass
- SKILL.md follows the Agent Skills formatthe description does not say when to use the skillgithub.com/matlab/simulink-agentic-toolkit/blob/HEAD/skills- ↗Finding
SKILL.md
View on GitHubConfiguring Code Interfaces
Configure how model elements map to generated code — storage classes for elements in models configured with data interface configuration, and service interfaces for elements in models configured with service interface configuration.
Prerequisite: For full functionality of the skill (such as function mapping, specifying the deployment type, and using service interface configuration),
the model needs to be configured with the ERT system target file (SystemTargetFile = "ert.tlc", or an ERT-based derivative such as ert_shrlib.tlc or a vendor ERT target). When the model is configured with the GRT system
target file (SystemTargetFile = "grt.tlc"), only basic configuration operations such as specifying the storage class of model elements are supported. To configure the model with the ERT system target file, use the neighboring skill simulink-configure-model-for-code-generation.
Requires:
- For models configured with the GRT system target file, a Simulink® Coder license is required.
- For models configured with the ERT system target file, an Embedded Coder® license is required.
When to Use
- When setting storage classes for inports, outports, states, or parameters through code mappings. If the project assigns storage classes through data objects instead (such as
Simulink.ParameterorSimulink.Signal), that is a different workflow — seereferences/code_mapping.md, which also covers the one case that must be configured on the object. - When specifying the code representation of signals, states (such as values that Unit Delay and Integrator blocks hold between steps), parameters, or data stores. For example, when mapping a model element in this category to a global or extern variable, or when placing its declaration in a designated
.hor its definition in a designated.cfile. These requests map model elements to storage classes even when the user never explicitly says "storage class" or "code mapping". - When making a parameter tunable in the generated code (a global parameter that the rest of the software can read and update).
- When mapping function names. This happens when the user explicitly names generated entry-points or any other type of generated functions. For example: "make the startup routine be called
mFunctions_startup". - When specifying data defaults or function defaults for code generation.
- When configuring the model with either data or service interface configuration for code generation.
- When linking a shared Embedded Coder dictionary to a model.
- When configuring sender-receiver or client-server interface patterns.
- When setting deployment types and function prototypes for generated code.
- When inspecting or verifying the current model interface. For example: "is this model set up for data interface or for service interface?", or "did my dictionary link take effect?"
When NOT to Use
- When configuring non-mapping-related aspects of the model for code generation (such as specifying the target platform, hardware, or objective). For these purposes, use the skill
simulink-configure-model-for-code-generation. - When opening, editing, or building a model or its structure. For these purposes, use the skill
building-simulink-models. - When customizing the exported A2L (ASAP2) calibration file — COMPU_METHODs, GROUPs, STD_AXIS→COM_AXIS, BIT_OPERATIONs, or VARIANT_CODING. For these purposes, use the skill
simulink-customize-a2l(coder.asap2.*). This skill owns the model-side calibration attributes that code mappings carry (Export,CalibrationAccess,BitMask,CompuMethod,DisplayIdentifier,Format) and that the A2L export then reads; it does not edit the A2L file. - When the code generation target is not C/C++ through Simulink Coder or Embedded Coder. For example, when it is one of these:
- HDL Coder, which uses
hdlcoder.*APIs and generates VHDL/Verilog. - Simulink PLC Coder, which generates IEC 61131-3 Structured Text.
- MATLAB Coder or GPU Coder, which generate C/CUDA code from MATLAB functions (these do not generate code from Simulink models).
- HDL Coder, which uses
- When using an API surface that does not rely on
coder.mapping.*orcoder.dictionary.*. The generated code is still C or C++, but uses different mapping APIs. For example, when the API surface is one of these:- AUTOSAR Classic or AUTOSAR Adaptive (
autosar.api.*). For authoring a Classic AUTOSAR software component — including its port, data, and service interface configuration — use the skillsimulink-author-classic-autosar-swc. - DDS (Data Distribution Service) code mapping
- C++ class code interface packaging (
SystemTargetFile = "ert.tlc"andCodeInterfacePackaging = "C++ class").
- AUTOSAR Classic or AUTOSAR Adaptive (
- When deploying the generated code for Embedded Linux.
This skill covers C Data Interface configuration when using Simulink Coder or Embedded Coder. The skill also covers C Service Interface configuration when using Embedded Coder.
Critical Guardrails
- Read-only inspection needs no permission — run it. Queries that do not modify the model or dictionary —
introspect_api,find(cm,...),model_read/model_query_params,getModelParameter/getDeploymentType/getDataStore,coder.dictionary/coder.mappinggetters — are safe. Run them freely to diagnose, detect mode, and verify; never stop to ask before a read. The confirmation gate below applies only to writes (save_system,slbuild,addEntry/set(entry,...)). - Call
introspect_api(inscripts/) BEFORE assigning any storage class, service, deployment type, or per-element property. It returns allowed values, valid properties, and the current mode (DataInterface vs ServiceInterface). This is a required first step — do NOT discover valid values by trial-and-error or repeated probing calls. Enumerate first, then set the value you learned is valid. - NEVER save or build the model on your own — always ask the user first. Do not call
save_systemorslbuild(or setGenCodeOnlyand build) without explicit user confirmation. Saving overwrites the user's model/dictionary on disk; building can be long-running and writes generated code. Configure the mappings, report exactly what you changed, ask, and wait for a yes. - STOP before creating any dictionary entry — do not write
addEntry/set(entry,...)until the user provides the actual values (pragmas, storage classes, interface entries encode project intent). - Link a shared Embedded Coder dictionary through
EmbeddedCoderDictionaryonly, and only throughmodel_edit(aconfigureop onconfig:<ModelName>). Never setDataDictionaryto bring in a coder dictionary — it fails silently, leaving the model resolved toDataInterface. Do not reach forset_param/get_paramon either parameter. Seereferences/coder_dictionary.md. - NEVER edit generated code — it is overwritten every build. All changes go to the model, code mappings, or dictionary.
- Do not manufacture configuration the user did not ask for. A Data Interface model builds from a default code interface with no code mapping object; create mappings only to override defaults.
- Configuring a parameter's storage class — pick the mechanism by where the parameter lives. Model workspace → always code mappings (
setModelParameter), even on GRT; never set.StorageClasson the object. External parameter object (base workspace or data dictionary) →.StorageClasson the object;setModelParametercannot address it. Seereferences/code_mapping.md. - Confirm any model-design or configuration change that a requested interface change depends on — before making it. Some code-interface configurations cannot be applied on the model as-is and require a prerequisite change to the model's design or configuration (for example, switching GRT→ERT for function mapping, deployment types, or Service Interface; requiring a fixed-step solver; converting to an export-function model). Such a change can alter or prevent code generation. Do not apply it silently — explain what the interface change requires, why, and wait for the user's yes.
Reference Files
references/simulink-configure-code-interfaces.md— mode selection, per-mode workflows, deployment types, per-model mappings in a model-reference hierarchy, and the end-to-end "fresh model → generated code" spinereferences/code_mapping.md—coder.mapping.*API: storage-class mechanisms, port/state mapping, function naming/prototypes, silent-failure detection and verification patternsreferences/coder_dictionary.md—coder.dictionary.*API: creating/linking dictionaries, entries and their properties (getAvailableProperties), communication methods
Copyright 2026 The MathWorks, Inc.
Files in this skill
6simulink-configure-code-interfaces skill questions
How do I install the simulink-configure-code-interfaces skill in Claude Code?
Run npx degit matlab/simulink-agentic-toolkit/skills-catalog/code-generation/simulink-configure-code-interfaces ~/.claude/skills/simulink-configure-code-interfaces. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the simulink-configure-code-interfaces skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
What is the difference between GRT and ERT support for this skill?
For GRT models, only basic configuration like specifying the storage class of model elements is supported. ERT models support full functionality including function mapping, deployment types, and service interface configuration.
How should I find valid values for storage classes or deployment types?
You should call the introspect_api before assigning any properties. This returns allowed values, valid properties, and the current mode to avoid trial-and-error.
Can I use this skill to edit an A2L (ASAP2) calibration file?
No, this skill manages model-side calibration attributes that code mappings carry, but it does not edit the A2L file itself. Use the simulink-customize-a2l skill for that purpose.
How do I link an Embedded Coder dictionary to a model?
You must link it through EmbeddedCoderDictionary only, and only through model_edit. Using DataDictionary to bring in a coder dictionary will fail silently.