Configuring LECPython for Siemens LOGO! S7 Protocol

Overview of LECPython and Siemens LOGO! Integration

LECPython is a Python wrapper that exposes the S7.Net and Modbus TCP client libraries originally written in C# to Python 3.x environments. The component packages .NET 8 assemblies inside a wheel distribution so that an embedded Common Language Runtime (CLR) host can load the compiled classes directly from a Python process without requiring the developer to author a separate C# project. From a single Python import, an integrator can address Siemens S7-200, S7-200 SMART, S7-300, S7-400, S7-1200, S7-1500, and LOGO! 8 controllers, plus Modbus TCP servers and other vendor families such as Mitsubishi MC Protocol, Omron FINS, and Allen-Bradley CIP. The repository is hosted at github.com/xeden3/LECPython.

Siemens LOGO! is a logic module positioned between a relay and a micro-PLC. Despite its compact footprint, the LOGO! 8 (6ED1052-xxx08-0BA0 family) implements an Ethernet interface that supports two application-layer protocols: Modbus TCP on TCP port 502 and the Siemens S7 communication protocol. The S7 stack exposed by LOGO! is the same code path inherited from the S7-200 series: it uses Transport Service Access Points (TSAPs) inside ISO-on-TCP (RFC 1006) TPDUs to identify the communication endpoint, rather than the slot/rack integer pair used by S7-300, S7-400, S7-1200, and S7-1500 CPUs.

Because S7-200 and S7-200 SMART share the same ISO-on-TCP framing but differ from the slot/rack family in their TSAP encoding, a Python client must be configured with TSAP pairs (Local TSAP / Remote TSAP) when targeting either of those two legacy series. LECPython since release 1.2.3.6 exposes the dual-purpose parameters rack_or_localTSAP and slot_or_destTSAP so the same connection object can speak both encodings. Setting them to slot/rack integers (e.g. 0, 1) addresses an S7-1200/1500; setting them to TSAP byte values (e.g. 0x0100, 0x0300) addresses an S7-200, S7-200 SMART, or LOGO!.

Prerequisites and Runtime Requirements

The integration has been verified on the following baseline. Other platforms may work but were not part of the reference testing matrix.

Installation Steps

1. Install .NET 8 Desktop Runtime from the Microsoft .NET download portal.
2. Confirm the runtime is reachable:

   dotnet --list-runtimes
   # Expect output:
   # Microsoft.NETCore.App 8.0.x ...
   # Microsoft.WindowsDesktop.App 8.0.x ...

3. Create a Python virtual environment:

   python -m venv .venv
   .venv\Scripts\activate
   python --version   # Python 3.12.x

4. Install LECPython from the GitHub repository distribution:

   pip install --upgrade pip
   pip install git+https://github.com/xeden3/[email protected]

   Replace the version tag with the latest release if a newer one is published.
5. Confirm the import path is intact:

   python -c "import lecpython; print(lecpython.__version__)"
   # Expect: 1.2.3.6 (or newer)

S7 Protocol Stack: LOGO!, S7-200, and S7-1200/1500

All Siemens S7 Ethernet controllers speak ISO-on-TCP (RFC 1006) as the transport layer and the proprietary S7 protocol (often called S7Comm) on top. The user-visible difference between product families is the way the connection is identified inside the ISO-on-TCP payload.

When LECPython receives the parameters rack_or_localTSAP and slot_or_destTSAP, the underlying C# wrapper inspects the PLC type the developer passes to the constructor. If the PLC type is S7200 or S7200Smart, the integers are interpreted as TSAP bytes. If the PLC type is any other S7 model (S7300, S7400, S71200, S71500), they are interpreted as rack/slot. The same numeric 0, 1 value pair therefore means "rack 0 slot 1" for an S7-1500 but would map to an invalid TSAP 0x0000, 0x0001 for an S7-200.

Why the LOGO! Defaults Sometimes Work Without TSAP Tuning

For LOGO! specifically, the standard S7-1200/1500 configuration of rack=0, slot=1 has been observed to establish a successful TCP connection and read/write basic markers and process images. This appears to be a permissive fallback inside the LOGO! S7 server: when a connection arrives with a non-standard TSAP, LOGO! 8 firmware accepts it if no other partner has reserved the same slot. The behavior is firmware-dependent and not documented by Siemens as a supported configuration. For deterministic commissioning, always set the LOGO! partner TSAP explicitly to 0x0100 (local) and 0x0300 (remote).

TSAP Configuration for S7-200 and S7-200 SMART

TSAPs are two-byte identifiers in the ISO-on-TCP TPDU. They serve the same purpose as IP+port for a higher-layer socket, but inside the private Siemens addressing domain. The high byte typically encodes the device class (CPU, CP, HMI, programming device) and the low byte encodes the connection slot.

Decoding TSAP Byte Values

When configuring LECPython, the rack_or_localTSAP and slot_or_destTSAP arguments can be passed as integers in either decimal or hex format. Decimal 256 and hex 0x0100 are identical values inside the C# wrapper. For S7-200/LOGO! targets, the canonical pairs to use are:

• Passive (server) connection from Python to a single LOGO!:

  rack_or_localTSAP = 0x0100   # 256 decimal
  slot_or_destTSAP  = 0x0300   # 768 decimal

• Second parallel connection for diagnostics:

  rack_or_localTSAP = 0x0101   # 257 decimal
  slot_or_destTSAP  = 0x0301   # 769 decimal

• LOGO! configured as Modbus TCP master (rare; S7 is server side): not applicable — the LOGO! S7 server side cannot be re-mapped by the Python client.

Python Code Example: Connecting to a LOGO! 8

The following Python 3.12 snippet connects to a LOGO! 8 at IP 192.168.0.10, reads the process-image output words VW0 and VW2, and writes a single marker byte. It demonstrates both the correct TSAP configuration for the S7-200 path and a fallback to Modbus TCP if S7 is unavailable.

from lecpython import PlcClient, PlcType, DataType

# LOGO! 8 inherits the S7-200 S7Comm stack.
# Use S7200 PLC type so the wrapper interprets the integers as TSAPs.
client = PlcClient(
    plc_type=PlcType.S7200,
    ip="192.168.0.10",
    rack_or_localTSAP=0x0100,   # 256 — PG local TSAP
    slot_or_destTSAP=0x0300,    # 768 — LOGO! S7 server TSAP
    timeout_ms=2000,
)

try:
    client.connect()

    # Read process image: 2 words starting at VW0 (virtual word address 0)
    values = client.read(DataType.Word, db_number=1, start=0, length=2)
    print("VW0, VW2 =", values)

    # Write a marker byte. LOGO! exposes marker memory as DB1 byte offsets.
    client.write(DataType.Byte, db_number=1, start=0, value=0xAB)

finally:
    client.disconnect()

Address Mapping for LOGO! 8

LOGO! does not expose classical S7 DBs. From the S7 client perspective the memory layout is aliased into a single DB (DB 1) with offsets corresponding to the LOGO! variable table.

These offsets are firmware-dependent. The reference table above matches LOGO! 8 BM (Basic Module) firmware FS04 and later. Validate against the actual LOGO! project under LOGO!Soft Comfort before deploying read/write logic.

Modbus TCP Fallback Path

If S7 connectivity fails (firewall blocking TCP/102, LOGO! on an older firmware that does not enable the S7 server, or coexistence issues with multiple S7 clients), fall back to Modbus TCP. LOGO! 8 listens on TCP/502 by default and exposes a Modbus register map:

LECPython Modbus example:

from lecpython import ModbusClient

mb = ModbusClient(ip="192.168.0.10", port=502, unit_id=1, timeout_ms=1500)
mb.connect()

# Read 24 digital inputs starting at coil 0
inputs = mb.read_coils(0, 24)
print("Inputs:", inputs)

# Read analog input AI1 (input register 52)
ai1 = mb.read_input_registers(52, 1)
print("AI1 scaled:", ai1[0])  # 0 … 1000

mb.disconnect()

Configuring LECPython With rack_or_localTSAP and slot_or_destTSAP

The dual-purpose parameters were introduced in LECPython 1.2.3.6 to clarify the historical confusion between TSAP-style and slot/rack-style connections. The rule is:

• If plc_type is S7200 or S7200Smart: arguments are TSAP bytes.
• Otherwise (S7300, S7400, S71200, S71500, Logo): arguments are rack and slot integers.

Troubleshooting Matrix

Version History and Firmware Compatibility

Always pin to a tagged release rather than the rolling default branch. The @v1.2.3.6 (or current latest tag) installed via pip install git+... guarantees reproducible dependency resolution.

Verification and Commissioning Procedure

1. Verify network reachability: ping 192.168.0.10 must succeed. If ping fails, the LOGO! may have IP conflict; check with LOGO!Soft Comfort > Online > Accessible Nodes.
2. Verify TCP/102 is open: Test-NetConnection 192.168.0.10 -Port 102 must return TcpTestSucceeded: True.
3. Verify the S7 server is enabled on the LOGO!:
   • LOGO!Soft Comfort → Tools → Ethernet Connections → confirm an S7 connection exists.
   • On the LOGO! hardware, navigate to Settings > Network > S7 Server and confirm it is ON.
4. Run the connection script from the verification block in section "Python Code Example". Successful output proves end-to-end correctness.
5. Read a known static value from a marker you can change via LOGO!Soft Comfort online mode to confirm data path integrity.
6. Write a test byte to a marker and confirm via the LOGO! display or LOGO!Soft Comfort that the value changed.
7. Disconnect cleanly and review the LOGO! diagnostic buffer (LOGO! menu > Diagnostics > Diagnostic Buffer) for any S7 connection error entries.

Edge Cases and Field-Proven Caveats

• Multiple parallel S7 connections. LOGO! 8 supports up to 8 S7 connections simultaneously. With LECPython, each PlcClient instance reserves one TSAP pair. If you need 8 concurrent clients, set the Local TSAP to 0x0100 through 0x0107 on each instance.
• CycLic polling from a Jupyter notebook. Jupyter’s kernel restart does not always release the underlying TCP socket cleanly. Add a atexit.register(client.disconnect) to prevent orphaned ISO-on-TCP sessions on the LOGO! that take 30 s to time out.
• Python GIL and S7.Net throughput. S7.Net is synchronous and blocks the OS thread. For multi-tag high-rate acquisition (above 10 Hz) wrap each tag in its own Python thread or use the asynchronous variant of LECPython if your version provides it.
• Network address translation. If the Python host and the LOGO! are on different subnets separated by a router, ISO-on-TCP may traverse the router only if the router permits TCP/102 and the LOGO! has a default gateway configured. LOGO! 8 ships without a default gateway by default.
• LOGO! behind a managed switch with IGMP snooping. Some industrial switches treat the heavy ISO-on-TCP traffic as multicast and silently drop frames. Disable IGMP snooping on the LOGO! VLAN or use a dedicated port.
• S7 PDU size. LOGO! 8 advertises a maximum PDU size of 240 bytes. LECPython negotiates this automatically. If you observe truncated reads, manually set the requested length to ≤ 240 bytes per call.

Frequently Asked Questions