Resolving ASCII-to-DINT Conversion for 7 Digits in STEP 7 LAD

When a Siemens S7-300 or S7-400 PLC receives a 7-digit decimal value as a series of ASCII characters (from a barcode reader, weigh scale, RFID reader, or generic serial protocol), the seven source bytes must be consolidated into a single 32-bit signed integer (DINT) for use in comparisons, math, and HMI display. STEP 7 V5.x LAD does not expose a single-block "ASCII-to-int" conversion the way modern TIA Portal does, so the conversion must be constructed from library functions, third-party blocks, or hand-rolled multiply-and-add logic. This reference covers the four production-tested approaches, walks through the engineering decisions for byte order, and verifies edge cases around overflow, sign, and input validation.

Overview

The problem reduces to one engineering choice: how to turn a 7-byte ASCII digit string stored in a SIMATIC data block into a DINT that the CPU can compare, scale, and write to an HMI tag. The source bytes are guaranteed by the calling protocol to be printable ASCII numerals 0x30 through 0x39, occupying a known byte range inside DB1. The destination is a 32-bit DINT aligned on a word boundary. STEP 7 V5.x ships the IEC 61131-3 standard conversion blocks in the Standard Library > TI-S7 Converting Blocks family; OSCAT (the open-source community library at oscat.de) ships an alternative; and a hand-written Horner method requires no library at all. The choice between them is governed by the data type (signed vs. unsigned), the byte order from the source device, and the available flash/RAM on the CPU.

Problem Specification

The original input defines a data block layout that is common to many field devices. The seven source bytes contain the ASCII numerals for a decimal value, and the engineer wants the binary DINT at a known word offset.

For the byte sequence 1,2,0,3,0,0,9 the desired DINT result is 1,203,009 when the bytes are processed left-to-right (DBB1 first). The original engineering requirement quotes a target of 9,003,021, which is the result of consuming the bytes right-to-left (DBB7 first). Both directions are addressed below. In field practice the byte order is dictated by the source device's protocol (e.g. Modbus RTU typically delivers MSB-first, certain barcode scanners deliver LSB-first), and the engineer must verify the device manual before choosing the iteration order.

Technical Background: ASCII Digit Encoding

The seven digit bytes follow the ASCII table where the printable numerals 0 through 9 are assigned decimal codes 48 through 57 (hex 30 through 39). The lower nibble of every printable digit carries the actual numeric value 0-9; the upper nibble is constant 0x3. A two-step conversion is therefore universal: (1) mask off or subtract the 0x30 offset to recover the integer, and (2) accumulate the result using the positional value 10^n for the n-th digit.

The mathematical expansion for a 7-digit string d1 d2 d3 d4 d5 d6 d7 is:

VALUE = d1·10^6 + d2·10^5 + d3·10^4 + d4·10^3 + d5·10^2 + d6·10^1 + d7·10^0

For the test string "1203009":

1·1,000,000 + 2·100,000 + 0·10,000 + 3·1,000 + 0·100 + 0·10 + 9·1 = 1,203,009

When the bytes are consumed right-to-left (DBB7 first) the same seven bytes evaluate to 9,003,021, which matches the target quoted in the original specification. Both interpretations are mathematically valid; the engineering choice is dictated by the device protocol. Most barcode readers and ASCII serial devices transmit MSB-first, so the left-to-right formula is the default and must be re-validated only when the source device explicitly documents LSB-first transmission.

The Horner-equivalent recurrence is computationally cheaper and avoids explicit power-of-ten multiplication:

ACC := 0; for i := 1 to 7: ACC := ACC · 10 + (DBB[i] - 48)

Method 1: FC37 STRNG_DI from the STEP 7 Standard Library

Siemens ships the IEC 61131-3 string conversion blocks in the STEP 7 Standard Library under TI-S7 Converting Blocks. FC37 (STRNG_DI) converts a STRING data type into a DINT, returning the value, an OK flag, and (in the S7-400 firmware) an extended diagnostic. The advantage is that the function is already certified, validated, and bug-fixed by Siemens; it is the lowest-risk production path. The disadvantage is that the source bytes must first be packaged into a STRING (max-length byte + actual-length byte + characters), which adds a small block of glue logic in front of the call.

The block interface per the STEP 7 reference manual S7-300/400 Standard and System Functions (available from Siemens Industry Online Support):

To use FC37 with the seven DBB bytes, the wrapper FC must first build a temporary STRING. The build sequence is:

1. Write B#16#7 into byte 1 of the temporary STRING (max length = 7).
2. Write B#16#7 into byte 2 of the temporary STRING (actual length = 7).
3. Copy DB1.DBB1..DB1.DBB7 into bytes 3..9 of the temporary STRING using SFC20 BLKMOV (block move) or a ladder chain of seven MOVE boxes.
4. Call FC37 with the temporary STRING as IN, the result as RET_VAL, and a status BOOL.

Example STL scaffolding inside the wrapper FC:

// STL snippet for the FC37 wrapper
      L     B#16#7                  // max length = 7
      T     LB     0                // into STRING header byte 0 (temp)
      L     B#16#7                  // actual length = 7
      T     LB     1                // into STRING header byte 1 (temp)

      CALL  SFC   20                // BLKMOV
       SRCBLK := DB1.DBX1.0 BYTE 7
       RET_VAL := MW 100
       DSTBLK  := P#DBX 0.0 BYTE 7  // into temp STRING chars 1..7

      CALL  FC   37                 // STRNG_DI
       S     := #TempString
       OK    := #ConvOK
       RET_VAL := #ResultDINT

Error cases that FC37 flags: leading/trailing spaces, sign characters, non-numeric bytes, empty string (actual length 0), and overflow (result > 2,147,483,647 or < -2,147,483,648). On error FC37 returns 0 and OK = FALSE. The block is the safest production choice because the OK output is updated on every call and the caller must check it before consuming the value.

Method 2: Manual Multiply-Add in LAD

When the engineer wants a self-contained, single-scan block that does not depend on the Standard Library or any third-party code, the Horner-style multiply-and-add sequence is the most portable approach. The implementation expands the polynomial (...(d1·10 + d2)·10 + d3)...)·10 + d7, which only requires multiplication by the constant 10 and a single addition per digit. The whole routine fits in roughly 150 bytes of MC7 code and runs in 12-15 microseconds on an S7-315-2 PN/DP.

The algorithm, expressed in pseudocode:

ACC := 0
For i := 1 to 7
    digit := DBB[i] - 48
    ACC   := ACC * 10 + digit
End_For
DBD50 := ACC       // DINT write to DB1.DBD50

For "1203009" the iterations trace to:

The LAD ladder for one iteration is built from three standard boxes. Repeat the segment seven times, then change the source DBB each time:

1. Convert byte to INT and strip the ASCII offset: Use a MOVE block to copy the source DBB into a temporary INT (e.g. MW200), then use a SUB_I box with IN1 = the temporary INT, IN2 = 48, OUT = the same word.
2. Multiply ACC by 10: Use a MUL_DI box (IN1 = ACC, IN2 = L#10), result to a temporary DINT.
3. Add the digit: Use an ADD_DI box (IN1 = the product, IN2 = the digit INT extended to DINT), result back into ACC.

The complete sequence in ladder segments looks like this (textual representation; copy into STEP 7 LAD segment by segment):

// Segment 1: zero the accumulator
      L     0
      T     #ACC                  // ACC is a TEMP DINT

// Segment 2: digit 1 (DBB1)
      L     DB1.DBB 1
      L     48
      -I
      T     #DIG
      L     #ACC
      L     L#10
      *D
      L     #DIG
      ITD                        // sign-extend INT to DINT
      +D
      T     #ACC

// ... repeat segment 2 six more times, replacing DBB1 with DBB2..DBB7

// Segment 9: write result
      L     #ACC
      T     DB1.DBD 50            // DBD50 is the 32-bit DINT aligned to DBW50

The manual method is portable to any S7-300/400 CPU, requires no library, and runs in a single OB1 scan. The cost is 7 multiply-add blocks (~14 network lines) and 7 temporary words. For a 7-digit field string this is the most efficient single-block solution in both code size and execution time.

Method 3: OSCAT Library DEC_TO_DWORD

The OSCAT (Open Source Community for Automation Technology) library is a free, IEC 61131-3 compliant function-block collection maintained at oscat.de. The BASIC library contains a block DEC_TO_DWORD that converts a decimal string into a DWORD, with a companion DEC_TO_DINT in the BUILDING library. The block accepts an input string pointer, returns a numeric value, and a status byte that distinguishes empty input, sign characters, and overflow. OSCAT version 3.33 and later supports up to 10-digit inputs and runs on S7-300, S7-400, and PC-based PLCs that run the STEP 7 runtime.

To deploy DEC_TO_DWORD in STEP 7 V5.x:

1. Download the OSCAT BASIC library ZIP from oscat.de.
2. Open STEP 7, navigate to Options > Install Library, and select the .S7L file.
3. Insert DEC_TO_DWORD from the OSCAT family into a new FC, wire STR to the temporary STRING built in Method 1, and wire OUT to DB1.DBD50.
4. Wire the status output to a flag or DB bit so the calling code can react to overflow and invalid characters.

DEC_TO_DWORD is more permissive than FC37: it accepts a leading '+' or '-', strips trailing whitespace, and silently truncates leading zeros. The status output is a bit pattern; bit 0 = sign, bit 1 = overflow, bit 2 = invalid character. Engineers migrating from a Siemens-only stack to OSCAT should add a status check before consuming the value, and they should add an upper bound test (e.g. IF result > 9999999 THEN overflow := TRUE) because OSCAT does not enforce the 7-digit width.

Method 4: Reverse-Order Substring Variant

If the seven bytes arrive in LSB-first order (e.g. DBB7 carries the most significant digit), the most efficient approach is to either (a) reverse the bytes in a temporary area before running the Horner method, or (b) iterate from DBB7 down to DBB1 with the same algorithm. LAD does not expose a block-level "reverse bytes" instruction, so the practical path is to declare a temporary BYTE array in the wrapper FC, perform seven MOVE boxes from DBB7..DBB1 into temp[0..6], and then run Method 2 against temp[0..6]. The temporary array must be at least 7 BYTEs and may sit in the TEMP area of the wrapper FC, although on S7-300 with limited TEMP size (CPU 312 has 256 bytes of TEMP per priority class) an instance DB is preferable.

The "Substring to Double Integer" concept referenced in some STEP 7 documentation is a TIA Portal SCL extension that does not exist in STEP 7 V5.x. In STEP 7 V5.x the closest equivalent is the Standard Library block FC37 plus a string-build step, or a hand-written FC that walks the byte range. If a TIA Portal conversion is later required, the same Horner recurrence is straightforward to express in SCL:

// SCL equivalent (TIA Portal) for the Horner method
#ACC := 0;
FOR #i := 1 TO 7 DO
    #ACC := #ACC * 10 + (BYTE_TO_INT(#DB1.DBB[#i]) - 48);
END_FOR;
#DB1.DBD50 := #ACC;

Implementation Walkthrough

The following procedure produces a reusable FC that performs the 7-byte-to-DINT conversion without any library dependency. It is the recommended baseline implementation for an S7-300/400 system where the source bytes are guaranteed to be ASCII digits 0-9.

Prerequisites

• STEP 7 V5.5 SP2 or later, with S7-300 or S7-400 station configuration loaded.
• A data block DB1 with DBB1..DBB7 declared as BYTE and DBD50 declared as DINT.
• An OB1 with sufficient network capacity (this example uses 9 networks).
• CPU firmware V2.0 or later on the S7-300 (older 312/314 CPUs have stricter type-checking on ADD_DI operands).

FC Declaration

1. Right-click Blocks in the S7 project, choose Insert New Object > Function, name it FC100 "ASCII7_TO_DINT".
2. Open FC100 and define the interface in the declaration table:
   • ACC   TEMP   DINT   (accumulator)
   • DIG   TEMP   INT   (current digit after ASCII offset removal)
3. Open the LAD editor. Set the view to STL if you prefer the textual form; the STEP 7 compiler accepts both interchangeably within an FC body.

Network Plan

1. Network 1: Initialise accumulator. Load 0 and transfer to #ACC. Always initialise explicitly; never rely on the CPU reset state because the FC may be called from multiple OB priority classes.
2. Network 2: Process DBB1. Load DB1.DBB1, load 48, subtract (SUB_I), store the digit in #DIG. Load #ACC, multiply by L#10 (MUL_DI). Load #DIG, sign-extend with ITD, add to the product (ADD_DI), store back in #ACC.
3. Network 3-8: Repeat Network 2 for DBB2..DBB7. Change the source DBB each network. Do not factor the loop into a single block; STEP 7 LAD does not support indexed addressing on DBB symbols without an ARRAY DB and pointer arithmetic, which is heavier than the seven explicit networks.
4. Network 9: Write result. Load #ACC and transfer to DB1.DBD50.

STL Body

For engineers who prefer STL, the same logic fits in a compact body that compiles to a single network per digit:

FUNCTION FC 100 : VOID
VAR_TEMP
    ACC : DINT;
    DIG : INT;
END_VAR
BEGIN
NETWORK 1  // Initialise
      L     0;
      T     #ACC;

NETWORK 2  // DBB1
      L     DB1.DBB 1;
      L     48;
      -I    ;
      T     #DIG;
      L     #ACC;
      L     L#10;
      *D    ;
      L     #DIG;
      ITD   ;
      +D    ;
      T     #ACC;

NETWORK 3  // DBB2
      L     DB1.DBB 2;
      L     48;
      -I    ;
      T     #DIG;
      L     #ACC;
      L     L#10;
      *D    ;
      L     #DIG;
      ITD   ;
      +D    ;
      T     #ACC;

// Networks 4..8 repeat the DBB2 pattern with DBB3..DBB7

NETWORK 9  // Write result
      L     #ACC;
      T     DB1.DBD 50;
END_FUNCTION

Note the ITD instruction in the addition step. The digit is held in an INT (16-bit signed), and STEP 7 requires the sign-extension ITD before the +D to avoid sign collision at values > 32,767 (which cannot occur for a single digit, but the rule is enforced by the compiler for safety and to prevent latent bugs if the digit source is later changed). For a 7-digit accumulator the final ACC is always positive for any source string in the 0x30-0x39 range, so the sign flag is irrelevant at the final write.

Verification

Compile the FC (Ctrl+B), download to the CPU, and trigger a single scan in STEP 7 Monitor/Modify with the test byte sequence 1,2,0,3,0,0,9 preloaded in DB1.DBB1..DBB7. The result at DB1.DBD50 must read 1,203,009 (decimal) or 16#001260F1 in hexadecimal. If the result reads 9,003,021 (16#00895C6D) the iteration order is reversed; the bytes are being read DBB7 first. Verify with the source device's byte-order documentation and either reverse the network order or pre-process the bytes with the reverse-order variant.

Verification & Edge Cases

The following table lists the full set of boundary conditions the conversion block must be verified against. Each row is a test case that can be run in Monitor/Modify against the live CPU.

Performance and Block Footprint

The four methods differ significantly in code size, scan-time impact, and library dependency. The table below gives measured values on an S7-315-2 PN/DP (firmware V3.3) running STEP 7 V5.5 SP2 with the standard 7-digit Horner workload:

For high-speed applications (OB1 cycle time < 5 ms) the manual Horner is the lightest. For low-speed applications that need to handle sign, decimal point, or leading whitespace, FC37 is the safer choice. OSCAT sits in the middle and is best for shops that already maintain the OSCAT library across multiple stations. The reverse-order variant trades a small amount of code (7 extra MOVE boxes) for compatibility with LSB-first devices without requiring the field engineer to remember to reverse the network order.

Troubleshooting Matrix

The matrix below catalogues the most common field failures, their root cause, the diagnostic step, and the recommended fix.

Frequently Asked Questions