parameters
/parameters
Drive parameters for SINAMICS drives. Use when reading/writing parameters, BiCo wiring, accessing parameters by index or name, and manipulating parameter bits.
- Author
- asckye ↗
- Repository
- tia_portal_openness_mcp ↗
- Licence
- MIT
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Drive parameters for SINAMICS drives. Use when reading/writing parameters, BiCo wiring, accessing parameters by index or name, and manipulating parameter bits.
Original author description
Drive parameters for SINAMICS drives. Use when reading/writing parameters, BiCo wiring, accessing parameters by index or name, and manipulating parameter bits.
How it works
- Overview
- Required Namespaces
- Required Assemblies
- Common Patterns
- Quick Reference
- Related Files
- Exception Handling
SKILL.md preview
---
name: parameters
description: Drive parameters for SINAMICS drives. Use when reading/writing parameters, BiCo wiring, accessing parameters by index or name, and manipulating parameter bits.
metadata:
siemens-depends-on: "openness-base, drive-objects"
---
# Parameters
## Overview
Drive parameters in SINAMICS drives are accessed through the `Parameters` collection on a `DriveObject`. Parameters can be retrieved by numeric index, by string name (e.g., `"r945[2]"`), or via `Find(index, subindex)` for BiCo wiring. Parameter bits provide granular control, enabling individual bit toggling for safety activation and feature flags.
## Required Namespaces
```csharp
using System.Linq;
using Siemens.Engineering;
using Siemens.Engineering.MC.Drives;
```
## Required Assemblies
- `Siemens.Engineering.Base.dll`
- `Siemens.Engineering.Step7.dll`
- `Siemens.Engineering.Startdrive.dll`
## Common Patterns
### BiCo Parameter Wiring
**Description:** Find a BiCo parameter by index and subindex, locate a target parameter bit, and assign the bit as the BiCo value. This creates a cross-wiring connection between parameters.
**Example:**
```csharp
var bicoParameter = redAxis.GetService<DriveObjectContainer>()
.DriveObjects.First()
.Parameters.Find(840, 0);
var connectedParameter = parameterBits.First(
x => x.Name.Substring(x.Name.IndexOf('.') + 1) == "7");
bicoParameter.Value = connectedParameter;
```
**Key Types and Methods:**
- `Parameters.Find(index, subindex)` — locate a BiCo-capable parameter by numeric address
- `Parameter.Value` — assign a `ParameterBit` reference as the BiCo source
- `ParameterBits` — collection of available bit references for wiring
### Read Parameter Value
**Description:** Read the current value of a drive parameter by accessing its `.Value` property. This is the most common parameter operation — retrieving the current setting of a parameter like `r945` (motor rated current) or any other read/writable parameter.
**Example:**
```csharp
var parameter = driveObject.Parameters.Find("r945[2]");
if (parameter != null)
{
var currentValue = parameter.Value;
Console.WriteLine($"Parameter {parameter.Name} = {currentValue}");
}
```
**Key Types and Methods:**
- `Parameter.Value` — get the current value of the parameter
- `Parameter.Name` — the SINAMICS parameter name (e.g., `"r945[2]"`)
### Parameter Access by Index
**Description:** Access a drive parameter via numeric index from the `Parameters` collection. Direct index access is the fastest way to retrieve a known parameter.
**Example:**
```csharp
var parameters = driveObject.Parameters;
var parameterViaIndexAccess = parameters[100];
```
**Key Types and Methods:**
- `Parameters[index]` — indexer to retrieve a parameter by numeric ID
- `Parameter` — the returned parameter object with `.Value`, `.Name`, `.Bits`
### Parameter Access by String Name
**Description:** Find a parameter using `Parameters.Find(string)` with the parameter name, e.g., `"r945[2]"` for read-only parameters or `"p999"` for writable ones.
**Example:**
```csharp
var parameterViaStringAccess = parameters.Find("r945[2]");
```
**Key Types and Methods:**
- `Parameters.Find(name)` — locate parameter by SINAMICS naming convention
- Read parameters use `"r"` prefix; write parameters use `"p"` prefix
### Parameter Bit Access by Name
**Description:** Access a specific bit of a parameter via the `.Bits` collection and filter by the fully qualified bit name (e.g., `"p9603.1"`). Setting bit values enables individual features like safety functions.
**Example:**
```csharp
parameters.Find("p9603").Bits
.Single(x => x.Name == "p9603.1")
.Value = 1;
```
**Key Types and Methods:**
- `Parameter.Bits` — collection of individual bits within a parameter
- `Bit.Name` — fully qualified name in `"parameter.bit"` format
- `Bit.Value` — set or read the bit value (0 or 1)
## Quick Reference
| Method/Pattern | Purpose |
|---|---|
| `Parameter.Value` (read) | Read the current value of a parameter |
| `Parameters.Find(index, subindex)` | Locate BiCo parameter by numeric address |
| `Parameters[index]` | Direct index access to a parameter |
| `Parameters.Find("r945[2]")` | Find parameter by string name |
| `Parameter.Bits.Single(x => x.Name == "p9603.1").Value` | Access and set individual parameter bits |
| `Parameter.Value = bit` | Assign a BiCo wiring connection |
## Related Files
- [`drive-objects`](../drive-objects/SKILL.md) — obtaining the `DriveObject` whose `Parameters` collection you access
- [`safety-commissioning`](../safety-commissioning/SKILL.md) — uses parameter bit writes (e.g., `p9603`, `p9604`) to activate safety functions
- [`telegrams`](../telegrams/SKILL.md) — telegram configuration interacts with parameter-based addressing
- [`hardware-and-modules`](../hardware-and-modules/SKILL.md) — hardware projection sets configuration entries that map to parameters
## Exception Handling
- `Parameters.Find(string)` returns `null` if the parameter name does not exist. Always check for null before accessing properties.
- `Parameters[index]` throws `IndexOutOfRangeException` for invalid parameter numbers.
- `Parameter.Bits.Single()` throws `InvalidOperationException` if the bit name is not found. Use `FirstOrDefault()` with null checks for robust code.
- Writing to read-only parameters (e.g., `"r..."` prefix) throws `EngineeringException`. Only `"p..."` parameters are writable.
- BiCo wiring requires both source and target to support BiCo. Verify BiCo capability before assignment.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · asckye/tia_portal_openness_mcp | 100 | MIT |
| thedaviddias/front-end-checklist | 100 | MIT |
| Alejo2075/claude-code-aws | 90 | MIT |
Database snapshot: 13.11.2026 · package version a74778c091d8 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100drive-objects
Drive objects and DriveFunctionInterface for SINAMICS drives. Use when locating DriveObjects, setting telegrams, writing drive parameters (scalar, BiCo, bit, indexed, DFI motor/encoder), handling Double-MoMo drives, refreshing drive state after writes, or accessing/deactivating drive objects. - 100safety-commissioning
Safety commissioning for SINAMICS drives. Use when configuring PROFIsafe functions like STO and SImO, updating safety checksums, setting safety axis type, activating safety parameter bits, and managing acceptance tests.