Siemens SIMOTION D425: Converting DINT Arrays to WORD Elements

Overview

The Siemens SIMOTION D425 is a high-performance motion controller from the SIMOTION D family, designed for complex multi-axis applications in packaging, printing, textile, and converting machinery. Programming is performed in SCOUT (or SCOUT TIA) using Structured Text (ST) per IEC 61131-3. A recurring engineering task when interfacing SIMOTION with WinCC Flexible / TIA Portal HMI panels is the conversion of array elements to individually addressable scalar tags, so each element can be logged, trended, or displayed as a discrete HMI field.

This reference covers three canonical conversion patterns observed in field engineering:

• Decomposing a WORD array into individually named scalar variables (word1, word2, …) for direct tag binding.
• Converting a DINT array (di_selected_RecipeCount[0..10]) to WORD elements using the IEC standard DINT_TO_WORD conversion operator for HMI logging.
• Stringifying an array of strings into a single delimited string for archive export or barcode generation.

For controller specifications, refer to the SIMOTION D4xx Operating Instructions on Siemens Industry Online Support.

Prerequisites

Data Type Specifications

SIMOTION ST follows IEC 61131-3 type semantics. The relevant elementary types for this conversion are:

Because DINT can hold negative values and magnitudes up to ±2.1×10⁹, a direct narrowing conversion to WORD requires the engineer to guarantee that the source values are within the unsigned 16-bit range. Otherwise the conversion is undefined per IEC 61131-3 and the runtime will produce the implementation-defined result (on SIMOTION, the low-order 16 bits are retained; negative values wrap to 0…65 535 modulo arithmetic).

Conversion Architecture

Three architectural patterns are used in production code. Selection depends on whether the HMI requires discrete tags (e.g. for Tag Logging with absolute tag references) or can consume an entire array via index variables.

Step-by-Step: Pattern A — Scalar Explosion for Legacy HMI

When WinCC Flexible cannot consume an array tag, explode the array into individually addressable WORD variables in the controller's global data block.

1. Declare the source array and the scalar target tags in the unit's VAR_GLOBAL section.
2. Implement a cyclic ST program (in a MCC or LAD/FBD chart's ST subprogram) that copies element by element.
3. Re-run the program on every cycle so the HMI always reads a consistent image.

INTERFACE
  VAR_GLOBAL
    (* Source DINT array, e.g. recipe count values 0..10 *)
    di_selected_RecipeCount : ARRAY[0..10] OF DINT;

    (* Exploded WORD targets for HMI logging *)
    wordarray : ARRAY[0..10] OF WORD;
  END_VAR
END_INTERFACE

IMPLEMENTATION
  PROGRAM explodeArrayToWord
  VAR
    i : DINT;
  END_VAR
  FOR i := 0 TO 10 DO
    wordarray[i] := DINT_TO_WORD(LIMIT(0, di_selected_RecipeCount[i], 65535));
  END_FOR;
  END_PROGRAM
END_IMPLEMENTATION

Step-by-Step: Pattern B — Single-Word Indexing

When the downstream consumer only needs one element at a time (typical for a HMI recipe view that scrolls through entries), expose a single 16-bit output and an index.

PROGRAM getWordByIndex
VAR_INPUT
  iIndex : DINT;   (* 0..10 *)
END_VAR
VAR_OUTPUT
  wValue  : WORD;
  bError  : BOOL;
END_VAR

IF (iIndex >= 0) AND (iIndex <= 10) THEN
  wValue := DINT_TO_WORD(LIMIT(0, di_selected_RecipeCount[iIndex], 65535));
  bError := FALSE;
ELSE
  wValue := 0;
  bError := TRUE;
END_IF;
END_PROGRAM

Bind wValue and iIndex as HMI tags. Drive iIndex from a HMI slider or UpDown control. The runtime index check guarantees that operator mis-entry (e.g. iIndex = 11) returns a clean zero and a diagnostic bError bit, instead of an out-of-bounds access that would trigger an IO-ACCESS-ERROR on the controller.

Step-by-Step: Pattern C — Array-to-Single-String Aggregation

For barcode or CSV archive export, an array of strings must be flattened into one delimited string. SIMOTION ST has no built-in join function, so a manual CONCAT loop is required.

FUNCTION_BLOCK StringJoiner
VAR_INPUT
  arrStrings : ARRAY[0..9] OF STRING[20];
  cSeparator : CHAR;   (* typically ',' or ';' *)
END_VAR
VAR_OUTPUT
  sResult : STRING[255];
END_VAR
VAR
  i : DINT;
END_VAR

sResult := '';
FOR i := 0 TO 9 DO
  IF (i > 0) THEN
    sResult := CONCAT(sResult, STRING(cSeparator));
  END_IF;
  (* Trim trailing zero-length entries *)
  IF (LEN(arrStrings[i]) > 0) THEN
    sResult := CONCAT(sResult, arrStrings[i]);
  END_IF;
END_FOR;
END_FUNCTION_BLOCK

The same pattern can be applied to a WORD array by first calling WORD_TO_STRING on each element, then concatenating with a delimiter. For JavaScript / TypeScript based HMIs (Web Navigator), the Array.from() static method provides an equivalent one-liner: Array.from({length:10}, (_,i) => arr[i]).join(',').

Data Logging with Converted Values

WinCC Flexible Tag Logging requires either scalar tags or array-tag-with-index. The exploded wordarray[0..10] from Pattern A can be bound directly:

1. In the HMI project, open Connections > Tags and create tags wordarray_0 through wordarray_10, each pointing to the corresponding array element via the controller's area pointer (e.g. DB.wordarray[i] in SIMOTION, the array is exposed as a contiguous block).
2. Configure a Data Log with one column per tag. Set the acquisition cycle to match the controller's IPO or servo task (typically 1–4 ms for fast process, 100–1000 ms for trends).
3. Enable Logging method = Circular log with a segment size of 50 000 records to prevent SD card wear on the HMI panel.

For Pattern B, the single tag wValue is logged continuously while the HMI increments iIndex synchronously, producing one row per element per cycle — suitable for snapshot debugging but not for high-speed trend logging.

Verification Procedures

1. Offline syntax check in SCOUT: Project > Compile > Check Consistency. Compiler error 1200-2E08 typically indicates an out-of-range array bound; error 1200-2E15 indicates a missing END_TYPE / END_VAR.
2. Online watch table: open the unit's instance DB in Watch table mode and verify that wordarray[i] updates as di_selected_RecipeCount[i] changes (use Force on the DINT source to inject test values 0, 1, 100, 32768, 65535, 65536, −1).
3. Range test: feed value 65 536 (one above WORD max). Expected: wordarray[i] = 0 per low-bit truncation if LIMIT is bypassed; if LIMIT is in place, wordarray[i] = 65535 and the HMI archive shows the clamped ceiling.
4. HMI tag test: in WinCC Flexible Tags, force each wordarray_N tag to a known value and verify it appears in the live trend. If the tag shows ??, the HMI connection is misconfigured (check the area pointer and the PLC–HMI connection name in PG/PC interface).
5. Archive round-trip: trigger a recipe change, export the resulting CSV from the data log, and confirm that column count equals wordarray length and that all values are within 0…65 535.

Troubleshooting Matrix

Performance Considerations

On a SIMOTION D425 with the default servo task at 1 ms, an n = 11 element loop with LIMIT + DINT_TO_WORD executes in < 0.5 µs per element (D425 measured at ≈ 0.04 µs / assignment in benchmark mode). The exploded-array pattern therefore has negligible impact on the deterministic cycle. Avoid the pattern for arrays larger than 1 000 elements; for those, expose the array tag directly to the HMI and let the HMI index the log column.

For arrays of REAL / LREAL values, prefer REAL_TO_WORD only when the value is guaranteed to lie in the integer range 0…65 535. For floating-point trend logging, bind the REAL tag directly and use the HMI's Decimal places attribute to control display precision.

Related Functions in the SIMOTION Standard Library

• DINT_TO_WORD(value) — narrowing conversion, retains low 16 bits.
• LIMIT(MN, IN, MX) — clamps IN to the range [MN, MX]; pair with DINT_TO_WORD to enforce range discipline.
• WORD_TO_INT(value) — widening sign-extension; useful when the HMI tag is INT and the source is WORD.
• CONCAT(s1, s2) — string concatenation for Pattern C; both operands are STRING, the CHAR must be cast via STRING() first.
• LEN(str) — returns the actual length of a STRING variable, used to skip empty array entries during join.

FAQ