SIMATIC IOT2020: Yocto Linux, Arduino, MQTT Gateway Setup Guide

SIMATIC IOT2020: Yocto Linux, Arduino Shield Integration, and Industrial IoT Gateway Reference

The SIMATIC IOT2020 is an open, Arduino-compatible industrial IoT gateway released by Siemens as part of its Siemens Automation Cooperates with Education (SCE) training initiative. The platform targets universities, vocational colleges, and engineering teams who need to prototype sensor-to-cloud applications on a Linux-based edge node before promoting logic into a real SIMATIC S7 controller. This technical reference consolidates verified hardware specifications, the official Yocto image workflow, Arduino sketch deployment, MQTT/OPC UA publishing, and the operational limits that distinguish the IOT2020 from a true SIMATIC distributed I/O station such as the ET 200S.

1. Product Positioning and Intended Use

The IOT2020 was positioned by Siemens as an entry-level node in its industrial IoT ecosystem. Typical use cases:

• Universities and technical schools in the SCE global training network, where students explore Linux, Arduino, and cloud telemetry side-by-side with PLC theory.
• Engineering teams prototyping sensor pre-processing, edge analytics, and cloud telemetry on a deterministic Linux stack.
• Maker-style integrators who require native Arduino sketch execution plus Linux tools (MQTT, OPC UA, Python) without PLC programming overhead.

It is explicitly not a replacement for a SIMATIC S7-1200/S7-1500 controller or an ET 200 distributed I/O head module. Its role is data concentration, protocol translation, and edge analytics in front of — not in place of — a deterministic automation controller.

2. Verified Hardware Specifications

The following table consolidates the specifications published in the official SIMATIC IOT2020 datasheet from the Siemens SCE portal. Always cross-check current revisions against the manufacturer document before ordering or designing around the device.

The absence of IEC 61131-2 certification is the critical limitation: the board cannot legally be marketed or installed as an industrial PLC or distributed I/O head in production machinery in many regions.

3. Architecture: Intel Quark X1000 vs. Raspberry Pi

The IOT2020 shares the same physical footprint as an Arduino Uno, not a Raspberry Pi. Confusion arises because both expose a multi-pin header and boot from microSD, but the internals differ materially:

Choosing between them is not a performance comparison — the IOT2020 is markedly slower than a Raspberry Pi 3 — but a tooling decision. If your application uses Arduino libraries and shields, the IOT2020 can compile and run them natively via the on-board Arduino IDE. A Raspberry Pi must emulate Arduino via software tools or use a dedicated Arduino coprocessor.

4. Arduino-Compatible I/O Pinout

The 36-pin Arduino shield headers (D0–D13, A0–A5, +5 V, +3.3 V, GND, VIN) map directly to the Quark SoC GPIO. Pin functions follow the standard Arduino Uno convention. Standard Arduino libraries (Wire, SPI, Servo, etc.) are usable without modification because the Intel Galileo profile mirrors the AVR register model.

5. Yocto Linux Image Installation

The IOT2020 does not have a writable on-board flash large enough for a root file system. All runtime code lives on a microSD card, which holds the Siemens-supplied Yocto image.

5.1 Prerequisites

• Industrial-grade microSD card, ≥ 4 GB, class 10 or higher; SLC or A1-rated cards recommended for environments with vibration or temperature stress
• Signed image file (typically .wic) downloaded from the official Siemens SCE portal
• Card reader and flashing tool: balenaEtcher, Win32 Disk Imager, or dd on Linux/macOS
• USB Type B cable for serial console access (115200 8N1) in case Ethernet provisioning fails

5.2 Flashing procedure

1. Download the latest signed image from the Siemens SCE SIMATIC IOT2020 page. Verify the SHA-256 checksum against the value published in the release notes before flashing.
2. Insert the microSD card into the host PC. Confirm the device path with lsblk on Linux or Disk Utility on macOS. Confirm the target device letter on Windows.
3. Flash the image with dd (Linux example):

   sudo dd if=iot2020-image.wic of=/dev/sdX bs=4M status=progress conv=fdatasync
   sync

   On Windows, use Win32 Disk Imager or balenaEtcher and select the .wic directly. balenaEtcher accepts raw images and verifies the write automatically.
4. Eject the card, insert it into the IOT2020, and apply 12 V DC. The board boots in approximately 25–35 seconds. Successful boot is indicated by a green heartbeat pattern on the user LED and an active link LED on the Ethernet RJ45.
5. Determine the assigned IP address from your DHCP server lease table, or attach via the serial console on USB Type B at 115200 8N1 if no DHCP server is reachable.
6. SSH into the device: ssh root@<ip-address>. The default credentials are documented in the SCE release notes; change the root password on first login with passwd.

5.3 Image customization with Yocto

To build a custom image, set up a Yocto workspace with the Siemens-supplied BSP layer. The IOT2020 BSP is built against the Poky Krogoth release branch:

git clone -b krogoth git://git.yoctoproject.org/poky.git
git clone -b krogoth https://github.com/siemens/meta-iot2020.git
cd poky
source oe-init-build-env build
bitbake-layers add-layer ../meta-iot2020
echo 'MACHINE = "iot2020"' >> conf/local.conf
bitbake iot2020-image

The build output appears in tmp/deploy/images/iot2020/ as a .wic file ready for direct flashing to an SD card. To add your own application, write a Yocto recipe under meta-yourcompany/recipes-apps/ and append it to the image's IMAGE_INSTALL list in local.conf.

6. Network Configuration and Communication Protocols

The IOT2020 reference image uses systemd-networkd. To assign a static IP, edit /etc/systemd/network/wired.network:

[Match]
Name=eth0

[Network]
Address=192.168.0.50/24
Gateway=192.168.0.1
DNS=192.168.0.1

Apply with systemctl restart systemd-networkd. Verify with ip addr show eth0 and ip route.

6.1 MQTT client (Eclipse Paho C)

The reference image bundles Mosquitto client tools and the Eclipse Paho C library. A minimal publisher in C:

#include <stdio.h>
#include <string.h>
#include "MQTTClient.h"

int main() {
    MQTTClient client;
    MQTTClient_create(&client, "tcp://broker.hivemq.com:1883",
                      "iot2020_pub", MQTTCLIENT_PERSISTENCE_NONE, NULL);
    MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer;
    opts.keepAliveInterval = 20;
    opts.cleansession = 1;
    MQTTClient_connect(client, &opts);

    MQTTClient_message pubmsg = MQTTClient_message_initializer;
    pubmsg.payload = "{\"temp\":23.4}";
    pubmsg.payloadlen = strlen(pubmsg.payload);
    pubmsg.qos = 1;
    pubmsg.retained = 0;

    MQTTClient_publishMessage(client, "siemens/iot2020/sensors", &pubmsg, NULL);
    MQTTClient_disconnect(client, 10000);
    MQTTClient_destroy(&client);
    return 0;
}

Compile against the Paho libraries in the Yocto SDK. Subscribe from any host with mosquitto_sub -h broker.hivemq.com -t "siemens/iot2020/#" -v.

6.2 OPC UA server (open62541)

For integration with SIMATIC controllers and SCADA systems, deploy an OPC UA server using the open62541 stack. Bind the server to 0.0.0.0:4840 and expose the analog input values as OPC UA variables. A SIMATIC S7-1500 (firmware ≥ V2.0) can subscribe as an OPC UA client and route data into the PLC program via the OPC_UA_Client instruction.

6.3 Modbus TCP gateway

The IOT2020 commonly acts as a Modbus TCP-to-MQTT bridge using libmodbus. Typical ports exposed by the reference image:

• Modbus TCP: 502
• MQTT: 1883 (plain) / 8883 (TLS)
• OPC UA: 4840
• SSH: 22; HTTP diagnostic UI: 80

Open firewall ports on the host side with firewall-cmd --permanent --add-port=502/tcp (or equivalent iptables rules) before commissioning.

7. Integration with SIMATIC Automation Systems

The IOT2020 is not a PROFINET device and cannot replace an ET 200 distributed I/O head. It connects to a SIMATIC PLC through:

• S7 communication via Snap7 library over ISO-on-TCP (port 102). The IOT2020 reads/writes data blocks from an S7-1200 or S7-1500 controller.
• OPC UA from S7-1500 (firmware ≥ V2.0) consuming variables exposed by the IOT2020.
• MQTT broker on the plant network, with the PLC subscribing via custom function blocks or uploading to MindSphere / Insights Hub via the MindConnect IoT extension.

A common architecture places the IOT2020 as a sensor concentrator at the field level, with aggregated data flowing to a higher-level system for analytics. The deterministic control loop stays inside the S7 controller; the IOT2020 handles non-critical telemetry only.

8. Comparison: SIMATIC IOT2020 vs. SIMATIC ET 200S

Rule of thumb: use the ET 200S when wiring a sensor directly into the SIMATIC automation cell and cycle time matters. Use the IOT2020 when extracting data to a higher-level system (cloud, dashboard, MQTT broker) and real-time guarantees are not required. For new designs, both should be replaced by their current successors — the IOT2050 family and the ET 200SP.

9. Troubleshooting Matrix

10. Industrial Suitability and Successor: SIMATIC IOT2050

The IOT2020 is intentionally a training platform. Its 0–40 °C operating temperature, lack of IEC 61131-2 conformance, and absence of PROFINET certification disqualify it from many production cabinets. For industrial environments, Siemens released the IOT2050 family:

Migration from IOT2020 to IOT2050 reuses the same Yocto workflow: the BSP layer meta-iot2050 replaces meta-iot2020. Custom application recipes transfer with minimal change because both platforms use systemd, Python 3, and standard Linux networking.

For higher-level industrial automation contexts — robotic cells, palletizing, machine tending, large-scale line integration — gateways like the IOT2050 typically feed data into SIMATIC PLCs and SCADA rather than driving motion directly. Robotic integration work runs through dedicated vendors with hardened controllers and certified safety chains. Broader industrial automation strategy and use-case framing is documented across the industry; see, for example, the KUKA industrial automation overview for a robotics-centric perspective.

11. Field-Commissioning Checklist

1. Verify power supply: regulated 12 V DC ± 5 %, 1 A minimum. Confirm polarity before applying power.
2. Insert flashed microSD before power-up. Cold-boot only — hot-plugging the SD card is not supported.
3. Capture the DHCP lease or assign a static IP via systemd-networkd and document the address on the asset register.
4. Update the root password on first login. Disable password SSH if key-based authentication is used in production.
5. Configure NTP and verify with timedatectl status. System clock synchronized: yes is required for log correlation.
6. Validate analog inputs with a calibrated 4–20 mA source through a 250 Ω shunt; confirm 4 mA maps to ~1.0 V and 20 mA to ~5.0 V (use averaging if noise is present).
7. Smoke-test MQTT or OPC UA publishing against the broker or SCADA; verify QoS 1 acknowledgements if used.
8. Document gateway firmware (image version, build date) and the tag ID in the plant asset register.
9. Apply any required country or region wireless certifications if a mini-PCIe radio is installed.
10. Schedule periodic SD card health checks — industrial-grade cards have a finite write endurance and should be replaced preventatively.

12. Standards and Protocol References

Engineers working with this platform should consult the official documentation rather than community guides for compliance and certification questions:

• SIMATIC IOT2020 product page (Siemens SCE) — image downloads, release notes, training material
• SIMATIC IOT2020 datasheet (PDF on the SCE portal) — pin-level electrical specifications, certification marks
• Yocto Project documentation — BSP layer structure, supported host distros, build configuration
• Intel Quark X1000 datasheet on Intel ARK — processor register definitions and electrical limits
• OPC Foundation OPC UA specification — interoperability and security profiles
• MQTT v5.0 specification (OASIS) — broker behaviour, QoS levels, topic wildcards
• Siemens Industrial IoT portfolio — successor products (IOT2050) and ecosystem context