Configuring SICK CLV630 PROFINET with S7-1500 in TIA Portal V15.1

System Overview

This reference documents the integration of a SICK CLV630-6120 fixed-mount barcode scanner with a Siemens SIMATIC S7-1515-2 programmable logic controller over PROFINET IO using TIA Portal V15.1. The scanner appears in the PROFINET topology as a standard IO device, exchanges cyclic I/O with the CPU, and exposes the decoded barcode string, status flags, and diagnostics over the fieldbus. The application scenario covered here is one of the most common in discrete-manufacturing and material-handling lines: a PLC triggers a scan, captures the decoded barcode from the input process image, and forwards the result to a higher-level IT system (MES, ERP, or warehouse server).

The behavior observed during commissioning is straightforward: setting a single output bit to TRUE arms the reading gate, the scanner fires its laser line, decodes whatever code is in the field of view, and writes the ASCII result plus status flags into the input process image. A typical working mapping uses Q1.0 as the trigger source and a 32-byte slice from IB2 to IB33 for the barcode payload. The two leading bytes (IB0-IB1) carry the scanner status word and are used by the application logic to confirm valid result availability before the data block is consumed.

The complete CLV63x/CLV64x/CLV65x device family is described in the SICK CLV63x/CLV64x/CLV65x Operating Instructions (PDF, IM0071081), which covers hardware installation, optical setup, the PROFINET GSDML-based integration, and the bit-level meaning of the cyclic I/O data. The function-block approach for the SICK PLB (Product Logistics Bridge) is documented separately in the SICK Support Portal article KA-08392, which provides a sample Siemens function block for TCP/IP communication between a SICK PLB and a SIMATIC PLC.

Hardware and Software Requirements

PROFINET I/O Slot Configuration

Once the GSDML is imported into TIA Portal, the CLV630-6120 appears in the hardware catalog under Other field devices > PROFINET IO > Sensors > SICK > CLV630. During device insertion the IO Controller automatically negotiates the cyclic slot configuration. The default slot layout used by the CLV630-6120 places the result data in input bytes and the trigger control in output bytes.

The exact start address in the I/O process image depends on the address assignment selected in TIA Portal. In the working reference project the input image starts at %IB0 and the output image at %QB0, giving:

• %IW0 – 16-bit status word
• %IB2..%IB33 – 32-byte barcode payload (the ASCII text of the decoded code)
• %QB0 – control byte; in the application code the active trigger bit is Q1.0, which the programmer copies to %QB0 (or wires directly to bit 0 of the output byte if the address assignment was offset).

Device Configuration in TIA Portal V15.1

1. Download the SICK CLV630 GSDML from the SICK product page and store it locally.
2. In TIA Portal open Options > Manage general station description files (GSD) and install the GSDML. TIA Portal will populate the hardware catalog with the CLV630 device entry.
3. In the Devices & Networks editor, drag the SICK CLV630-6120 from the catalog onto the PROFINET subnet attached to the S7-1515-2 X1 interface.
4. Assign a unique PROFINET device name (for example clv630-1) and a static IP address consistent with the subnet. The CLV630 can also receive its name from the PLC via DCP if PROFINET naming is enabled.
5. In the device properties, open Device view and inspect the slot list. Verify that Slot 0 / Sub-slot 1 (Status) and Slot 1 / Sub-slot 1 (Reading Data) are present and not greyed out.
6. If your scanner firmware supports alternate I/O sizes (for example 16-byte or 64-byte data blocks), confirm the slot length matches the data layout you want. The default 32-byte data block matches the IB2..IB33 mapping observed during commissioning.
7. Set the IO addresses. In the Properties panel under I/O addresses assign the input start address to 0 and the output start address to 0 to reproduce the reference mapping.
8. Configure update time. For a 1200 Hz scanner the cycle time can be as low as 1 ms. With an S7-1515-2 a 1 ms send clock for the PROFINET IO is supported; if you also have IRT motion devices on the same subnet, configure the IRT topology accordingly.
9. Compile and download the hardware configuration to the PLC. The CLV630 will receive its PROFINET name via DCP at the next power-on or topology discovery.
10. Once the device shows up in the online diagnostics with a green checkmark and no channel-level diagnostic alarms, the I/O exchange is live.

Trigger and Reading-Cycle Implementation

The CLV630-6120 reading gate is armed by the trigger bit in the output control byte. In the reference project the application sets Q1.0 TRUE to start a scan, waits for the ResultAvailable bit in the status word to assert, copies the 32-byte payload from IB2..IB33 into a string tag, and then clears the trigger. A clean edge-triggered implementation in SCL is shown below.

// FB_TriggerScan — Single-shot read cycle against SICK CLV630
// Inputs : i_bStart   (BOOL)  — request to fire one reading
//          i_tTimeout (TIME)  — maximum wait for ResultAvailable
// Outputs: o_sCode    (STRING) — decoded barcode, ASCII
//          o_bOK      (BOOL)  — TRUE if a valid result was captured
//          o_bTimeout (BOOL)  — TRUE if no result within timeout
//          o_bError   (BOOL)  — TRUE if scanner reports error

IF i_bStart AND NOT i_busy THEN
    i_busy := TRUE;
    o_bOK := FALSE;
    o_bTimeout := FALSE;
    o_bError := FALSE;
    o_sCode := '';
    // Set trigger bit Q1.0 (mirrors into %QB0 bit 0 of the CLV630 slot)
    Q1.0 := TRUE;
    i_tStart := CURRENT_TIME();
END_IF;

IF i_busy THEN
    // Wait for status word bit 0 (ResultAvailable) — sits in %IB0
    IF "Status_CLV630".ResultAvailable THEN
        // Copy 32 bytes from IB2..IB33 into a STRING tag
        o_sCode := CHAR_TO_STRING(STRING_FROM_BYTES("Data_CLV630".Barcode));
        Q1.0 := FALSE;
        i_busy := FALSE;
        o_bOK := TRUE;
    ELSIF (CURRENT_TIME() - i_tStart) > i_tTimeout THEN
        Q1.0 := FALSE;
        i_busy := FALSE;
        o_bTimeout := TRUE;
    END_IF;
END_IF;

The data block Data_CLV630 is a 32-byte AT-view over the process image:

DATA_BLOCK "Data_CLV630"
  STRUCT
    Barcode : ARRAY[0..31] OF BYTE;   // AT %IB2 : ARRAY[0..31] OF BYTE;
  END_STRUCT;
END_DATA_BLOCK

DATA_BLOCK "Status_CLV630"
  STRUCT
    ResultAvailable : BOOL;           // %I0.0
    NoRead          : BOOL;           // %I0.1
    Error           : BOOL;           // %I0.2
    QualityGood     : BOOL;           // %I0.3
    DeviceReady     : BOOL;           // %I0.4
    Reserved        : ARRAY[0..10] OF BOOL; // %I0.5 .. %I1.7
  END_STRUCT;
END_DATA_BLOCK

For ladder programmers the same logic collapses to an S_ODT timer driving the trigger bit, a contact on the ResultAvailable bit, and a BLKMOV (or READ_DBL) from the input area into a string tag. In either language the important rule is to never read the barcode bytes before ResultAvailable asserts; otherwise you may capture residual data from the previous reading or the uninitialised power-on state.

Reading Result Data Structure and Parsing

The 32 bytes in IB2..IB33 contain the ASCII representation of the decoded barcode. SICK uses a left-justified, space-padded layout: the leading bytes are printable characters, the trailing bytes are ASCII $20 (space) when the code is shorter than 32 characters. A typical Code-128 result for a 14-character shipping container code looks like:

To turn the byte array into a usable STRING tag, strip trailing $20 bytes (and any other pad character your application configured in SOPAS). The SCL snippet below produces a clean, trimmed result and also flags when the scanner reported NoRead.

// FB_ParseResult — Trim trailing pad bytes from the result buffer
// Input : i_bResultAvailable (BOOL), i_bNoRead (BOOL)
//         i_bRaw : ARRAY[0..31] OF BYTE
// Output: o_sCode (STRING[64]), o_bNoRead (BOOL)

IF i_bNoRead THEN
    o_sCode := '';
    o_bNoRead := TRUE;
    RETURN;
END_IF;

o_bNoRead := FALSE;
// Copy bytes into a temporary STRING[32]
"tmp".s32 := '';
FOR i := 0 TO 31 DO
    "tmp".s32 := CONCAT("tmp".s32, CHAR_TO_STRING(BYTE_TO_CHAR(i_bRaw[i])));
END_FOR;
// Trim right whitespace and NULs
o_sCode := LTRIM_IMPL("tmp".s32, ' ');
o_sCode := LTRIM_IMPL(o_sCode, '$00');

Server Communication Architecture

Once the PLC owns a clean barcode string, the next problem is to push it to a server. The S7-1515-2 supports several transport options natively; the most common are listed below.

OPC UA Server Publication

The S7-1500 firmware ships with a built-in OPC UA server. Enabling it requires three configuration steps in TIA Portal.

1. Open the CPU properties and select OPC UA Server > General. Tick Activate OPC UA Server.
2. Define the server port (default 4840) and the security policy. For a closed manufacturing cell, leave None enabled. For factory-wide deployments, enable Sign + SignAndEncrypt with X.509 certificates.
3. Under OPC UA Server > Runtime licenses confirm that the CPU has an OPC UA license (S7-1515-2 includes OPC UA server capability without an additional license up to a session count defined by the firmware).
4. In the project tree, right-click the o_sCode STRING tag (the barcode string) and choose Accessible from OPC UA > Read/Write. TIA Portal will register the tag in the server address space.
5. Compile, download, and use any OPC UA client (UaExpert, Node-RED, Ignition, Kepware, custom Python with asyncua) to subscribe to the tag. A subscription triggers a notification every time the tag changes, which is exactly the behaviour required to stream scans to an MES.

An OPC UA client poll of the form ns=1;s=BarcodeStream returns the most recent barcode. If you need per-scan history rather than last-value, push the values into a small DB queue and expose a method on the OPC UA server that returns the queue on request.

TCP/IP Socket Communication with TSEND_C

If the target is a plain TCP server (a Python listener, a Node-RED flow, an industrial gateway), use TSEND_C from the TIA Portal instruction palette. The instruction handles connection establishment, data transfer, and disconnection. A typical implementation sends a JSON line for each successful scan.

// FB_PushBarcode — Send barcode over TCP to a remote listener
// Partner configured in IDB "PartnerDB" (IP, port, connection ID, etc.)

// Build JSON payload
"tmp".json := CONCAT('{"timestamp":"', UINT_TO_STRING("clock".unix_ts), '",');
"tmp".json := CONCAT("tmp".json, CONCAT('"code":"', o_sCode));
"tmp".json := CONCAT("tmp".json, CONCAT('","result":"', SEL(i_bNoRead, 'OK', 'NOR'))); 
"tmp".json := CONCAT("tmp".json, '"}');
"tmp".json := CONCAT("tmp".json, '$0A'); // newline terminator for line-based parsers

// Move into a BYTE buffer
"sendBuf".len := LEN("tmp".json);
Strg_To_Chars(src := "tmp".json, dst := "sendBuf".data, len := "sendBuf".len);

// Trigger TSEND_C
TSEND_C_DB.REQ := TRUE;
TSEND_C_DB.CONT := TRUE;
TSEND_C_DB.LEN  := "sendBuf".len;
TSEND_C_DB.DATA := "sendBuf".data;

Configure the connection once at runtime start using the TCON block inside the same DB:

// One-shot connection to the server, e.g. 192.168.10.50 : 9000
TCON_DB.REQ := TRUE;
// Connect parameters
TCON_DB.ID            := 1;
TCON_DB.CONNECTION_ID := 1;
TCON_DB.ACTIVE_EST    := TRUE;        // PLC acts as TCP client
TCON_DB.REMOTE_PORT   := 9000;
TCON_DB.REMOTE_IP     := 192_168_10_50;
// TCON_DB.CONNECT will assert when the socket is up

MQTT and SICK PLB Integration

For an MQTT broker the S7-1500 firmware since V2.6 includes a lightweight MQTT client (active on CPUs with a Mqtt instruction set in the TIA Portal library). The instruction publishes a topic such as factory/line1/clv630/result with a JSON payload identical to the TSEND_C example. Broker connection details (URI, port, TLS, credentials, last-will topic) are configured once in the DB.

When the target is a SICK PLB system, the SICK Support Portal article KA-08392 provides a reference Siemens function block that wraps the TCP/IP exchange with the PLB. The block handles session establishment, cyclic data forwarding, and acknowledgement. To use it:

1. Download the FB from the KA-08392 attachment and import it into your TIA Portal library.
2. Drag the FB into your program and connect its inputs to the o_sCode string and to the scanner status bits.
3. Configure the PLB IP address and TCP port in the instance DB.
4. Call the FB in a cyclic OB (OB1) — the FB itself manages state internally.

Diagnostic Word and Error Handling

The 16-bit status word in %IW0 is the primary health channel. The bit meanings below are consistent with the CLV630-6120 PROFINET profile; always cross-check with the CLV63x/64x/65x operating instructions for the exact firmware revision you are commissioning.

A robust application logic gates the trigger on DeviceReady, captures data only when ResultAvailable asserts, latches a fault on Error, and logs a NOREAD event when NoRead asserts without ResultAvailable. This four-state matrix handles every plausible scanner response without producing phantom reads.

Trigger–Read Timing

The four reference points describe the cycle:

• t0 – PLC raises Q1.0 and starts a watchdog timer.
• t1 – Scanner detects the trigger and starts its internal exposure sequence.
• t2 – Scanner has finished decoding; ResultAvailable asserts and the data block in IB2..IB33 is stable.
• t3 – PLC has copied the data block and de-asserts Q1.0.

The total cycle time t3 - t0 is dominated by the scanner's exposure and decode time, typically 10–50 ms at default SOPAS settings. Tightening SOPAS for higher scan rates shortens t2 - t1 at the cost of depth-of-field margin.

Troubleshooting Matrix

Verification Procedure

1. In TIA Portal, open Online > Go online and confirm a green status icon on the CLV630 node. Open the Diagnostics panel and verify zero active channel diagnostics.
2. Open a watch table bound to %IB0..%IB33 and %QBx. Force Q1.0 TRUE.
3. Present a known barcode to the scanner. Observe the transition of %I0.0 (ResultAvailable) and the appearance of the ASCII text in %IB2..%IBxx.
4. Compare the ASCII buffer with the printed code. Confirm that trailing space padding is the only difference if the code is shorter than 32 characters.
5. If the server channel is OPC UA, open UaExpert, browse to the server endpoint, and subscribe to the barcode tag. Force a new scan and verify the subscription receives a notification.
6. If the server channel is TSEND_C, run nc -lk 9000 (or a Python socket listener) on the partner host. Force a scan and verify a JSON line is received on the listener.
7. Disable the trigger and leave the scanner idle for 60 s; verify the status word returns to its steady state and that no spurious data appears in the buffer.
8. Document the working slot configuration, address map, server URL, and any SOPAS parameters that were changed from defaults, and store the GSDML version in the project archive.