{"id":28335,"date":"2025-01-17T12:57:47","date_gmt":"2025-01-17T12:57:47","guid":{"rendered":"https:\/\/www.horter.de\/blog\/?p=28335"},"modified":"2026-01-08T18:14:32","modified_gmt":"2026-01-08T18:14:32","slug":"i2c-modbus-tcp-server","status":"publish","type":"post","link":"https:\/\/www.horter.de\/blog\/i2c-modbus-tcp-server\/","title":{"rendered":"I2C-Arduino-Master als Modbus TCP-Server"},"content":{"rendered":"

In diesem Beitrag zeige ich, wie ein Arduino als I2C\u2011Master<\/strong> arbeitet und gleichzeitig als Modbus\u2011TCP\u2011Server<\/strong> fungiert. Damit lassen sich Daten von I2C\u2011Modulen einfach auslesen und \u00fcber das Netzwerk an eine SPS oder andere Steuerungen weitergeben.<\/p>\n

Ein praktisches Beispielprogramm zeigt, wie die Messwerte \u00fcbertragen werden, sodass du direkt loslegen kannst \u2013 ideal f\u00fcr Projekte, bei denen I2C\u2011Sensoren in industrielle Netzwerke integriert werden sollen.<\/p>\n\n

Hardware<\/h2>\n
\"I2C-Arduino-Master<\/a>

I2C-Arduino-Master f\u00fcr die Hutschiene<\/p><\/div>\n

F\u00fcr diese Applikation wird das I2C-Master Modul verwendet.<\/p>\n

– Frei programmierbar mit Arduino-IDE
– Status-LED f\u00fcr SDA, SCL und INT
– Jumper zum aktivieren der Terminierung
– Blaue LED frei programmierbar. Z.B. f\u00fcr Status der LAN-Verbindung
– Steckplatz f\u00fcr WizNET W5500 LAN-Modul
– BUS-Stecker zum Anschluss weiterer I2C-Module
– Steckplatz f\u00fcr USB-RS232 Programmieradapter<\/p>\n

Aufbau<\/h2>\n
\"\"<\/a>

Beispiel Hardware f\u00fcr den I2C-Modbus-TCP-Server<\/p><\/div>\n

F\u00fcr unser Beispiel ist als Kopf der Arduino-I2C-Master mit gestecktem WizNET W5500 LAN-Modul. Daneben folgende Module
– Digitale I2C-Eingangskarte I2HE (Slave-Adresse 112)
– Digitale I2C-Ausgangskarte I2HA (Slave-Adresse 64)
– Analoge I2C-Eingangskarte I2HAE (Slave Adresse 16)
– Analoge I2C-Ausgangskarte I2HAA (Slave Adresse 176)<\/p>\n

Software Modbus-TCP-Server<\/h2>\n

Die Modbus-TCP-Bibliothek f\u00fcr den Arduino kommt von Andr\u00e9 Sarmento Barbosa
http:\/\/github.com\/andresarmento\/modbus-arduino<\/a><\/p>\n

Ich habe in paar verschiedene Bibliotheken ausprobiert und diese hat auf Anhieb super funktioniert.<\/p>\n

Diese Bibliotheken werden ben\u00f6tigt:<\/p>\n

#include<\/span> <Wire.h><\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/ I2C-Lib<\/span>\n#include<\/span> <avr\/wdt.h><\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\/\/ Watchdog<\/span>\n#include<\/span> <Modbus.h><\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/ ArduinoRS485 library<\/span>\n#include<\/span> <ModbusIP.h><\/span> \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/ Modbus<\/span><\/pre>\n
Dann muss die IP-Adresse angegeben werden, \u00fcber die Der I2C-Master mit der SPS-Steuerung kommuniziert<\/div>\n
\n
\n
\/\/ModbusIP object<\/span>\nModbusIP mb;\nbyte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };  \nbyte ip[] = \u00a0{ 192, 168, 1, 7};<\/pre>\n
Dann definieren wir die Variablen f\u00fcr die verwendeten Raspberry-SPS-Baugruppen.
Sollen mehrere Eingangskarten verwendet werden, einfach die drei Zeilen eines Blocks kopieren und aus der 1 eine 2 machen u.s.w.<\/p>\n<\/div>\n
\n
\n
\/\/ I2C-Baugruppen definieren und globale Variablen anlegen\n#define<\/span> I2E1_ADDR<\/span> \u00a0112 >> 1 \u00a0 \/\/ I2C-Digital INPUT \u00a0Addresse als 7 Bit<\/span>\nint<\/span> \u00a0I2E1_WERT=0;\nbool<\/span> I2E1_OK;\n#define<\/span> I2A1_ADDR<\/span> \u00a0 64 >> 1 \u00a0 \/\/ I2C-Digital OUTPUT Addresse als 7 Bit<\/span>\nint<\/span> I2A1_WERT=0;\nbool<\/span> I2A1_OK;\n#define<\/span> I2AE1_ADDR<\/span> \u00a016 >> 1 \u00a0 \/\/ I2C-Analog \u00a0INPUT \u00a0Addresse als 7 Bit<\/span>\nint<\/span> I2AE1_WERT[5];\nbool<\/span> I2AE1_OK;\n#define<\/span> I2AA1_ADDR<\/span> 176 >> 1 \u00a0 \/\/ I2C-Analog \u00a0OUTPUT Addresse als 7 Bit<\/span>\nint<\/span> I2AA1_WERT[4];\nbool<\/span> I2AA1_OK;<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
Im Bereich Setup werden die Pin-Modes und die serielle Schnittstelle eingestellt.
Weiter unten kommt der Start und die Konfiguration vom Modbus-Server.
Die input-Register k\u00f6nnen von der SPS nur gelesen werden. In die Holding-Register kann die SPS Werte schreiben, die dann vom Modbus-TCP-Server gelesen und verarbeitet werden k\u00f6nnen.<\/p>\n
\n
\u00a0 \/\/ Modbus-TCP Server starten<\/span>\n  \/\/ -------------------------<\/span>\n  Serial.println<\/span>(\"Modbus TCP Server\"<\/span>);\n  mb.config<\/span>(mac, ip);\n\n  \/\/ Input-Register anlegen (Server -> SPS)<\/span>\n  mb.addIreg<\/span>(0); \u00a0\/\/ Input-Register 0 = 30001 in der SPS<\/span>\n  mb.addIreg<\/span>(1); \u00a0\/\/ Input-Register 1 = 30002 in der SPS<\/span>\n  mb.addIreg<\/span>(2); \u00a0\/\/ Input-Register 2 = 30003 in der SPS<\/span>\n  mb.addIreg<\/span>(3); \u00a0\/\/ Input-Register 3 = 30004 in der SPS<\/span>\n  mb.addIreg<\/span>(4); \u00a0\/\/ Input-Register 4 = 30005 in der SPS<\/span>\n  mb.addIreg<\/span>(5); \u00a0\/\/ Input-Register 5 = 30006 in der SPS<\/span>\n\n  \/\/ Holding Register anlegen (SPS -> Server)<\/span>\n  mb.addHreg<\/span>(0); \u00a0\/\/ Holding-Register 0 = 40001 in der SPS<\/span>\n  mb.addHreg<\/span>(1); \u00a0\/\/ Holding-Register 1 = 40002 in der SPS<\/span>\n  mb.addHreg<\/span>(2);  \/\/ Holding-Register 2 = 40003 in der SPS<\/span>\n  mb.addHreg<\/span>(3); \u00a0\/\/ Holding-Register 3 = 40004 in der SPS\n<\/span>  mb.addHreg<\/span>(4);  \/\/ Holding-Register 4 = 40005 in der SPS<\/span><\/pre>\n<\/div>\n
Im Loop-Bereich wird als erstes die Eingangskarte \u00fcber den I2C-Bus eingelesen. Die Funktion I2E ist im Arduino-Programm ganz unten im Bereich „Globale Funktionen“ programmiert. Die Funktion kann f\u00fcr mehrere Karten immer wieder aufgerufen werden.<\/p>\n
Der eingelesene Wert wird dann in das Modbus-Register o eingetragen. Der Wert erscheint dann in der SPS im Register 30001<\/p>\n
\n
\u00a0 \/\/ Einlesen der Bits von der I2C-INPUT Karte<\/span>\n  \/\/ ------------------------------------------<\/span>\n  \/\/ 8-Bit von der Eingangkarte lesen<\/span>\n  I2E<\/span>(I2E1_ADDR, I2E1_WERT, I2E1_OK); \/\/ Ein Byte von der DI-Karte Adr. 112 lesen<\/span>\n  if<\/span> (I2E1_OK == 0<\/span>) {\n  \u00a0 Serial.print<\/span>(\"Keine Antwort vom Slave \"<\/span>);\n  \u00a0 Serial.println<\/span> (I2E1_ADDR);\n  }\n  \/\/ Wert zur SPS<\/span>\n  mb.Ireg<\/span>(0, I2E1_WERT) ; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/ Input-Register 0 = 30001 in der SPS<\/span><\/pre>\n
\u00a0<\/div>\n<\/div>\n
Der n\u00e4chste Programm-Block schreibt den Wert aus dem Holding-Register 40001 zur digitalen Ausgangskarte<\/p>\n
\n
\n
\u00a0 \/\/ Ausgeben der Bits an die I2C-OUTPUT Karte<\/span>\n  \/\/ ------------------------------------------ \u00a0<\/span>\n  \/\/ Wert von der SPS umrangieren<\/span>\n  I2A1_WERT = mb.Hreg<\/span>(0); \u00a0 \u00a0 \u00a0 \u00a0 \u00a0   \/\/ Holding-Register 0 = 40001 in der SPS<\/span>\n  \/\/ 8-Bit zur Ausgangskarte schicken<\/span>\n  I2A<\/span>(I2A1_ADDR, I2A1_WERT, I2A1_OK);<\/pre>\n<\/div>\n<\/div>\n
Anschlie\u00dfend werden die analogen Eing\u00e4nge mit der Funktion
I2AE<\/span>(I2AE1_ADDR, I2AE1_WERT, I2AE1_OK);
eingelesen und in die Input-Register 1-5 einsortiert.
Die erscheinen dann in der SPS in den Registern 30002 bis 30006)<\/p>\n
\n
\u00a0 \/\/ Analogwerte einlesen und berechnen<\/span>\n  \/\/ ----------------------------------<\/span>\n  \/\/ Werte von Analogkarte lesen<\/span>\n  I2AE<\/span>(I2AE1_ADDR, I2AE1_WERT, I2AE1_OK);\n  \/\/ Werte zur SPS<\/span>\n  mb.Ireg<\/span>(1, I2AE1_WERT<\/span>[0]); \u00a0\/\/ Input-Register 1 = 30002 in der SPS<\/span>\n  mb.Ireg<\/span>(2, I2AE1_WERT<\/span>[1]); \u00a0\/\/ Input-Register 2 = 30003 in der SPS<\/span>\n  mb.Ireg<\/span>(3, I2AE1_WERT<\/span>[2]); \u00a0\/\/ Input-Register 3 = 30004 in der SPS<\/span>\n  mb.Ireg<\/span>(4, I2AE1_WERT<\/span>[3]); \u00a0\/\/ Input-Register 3 = 30005 in der SPS<\/span>\n  mb.Ireg<\/span>(5, I2AE1_WERT<\/span>[4]); \u00a0\/\/ Input-Register 3 = 30006 in der SPS<\/span><\/pre>\n<\/div>\n
Die Analogen Ausg\u00e4nge werden mit der Funktion
I2AA<\/span>(I2AA1_ADDR, I2AA1_WERT, I2AA1_OK);
zur Analogkarte gesendet. Vorherm\u00fcssen aber die Werte von den Holding-Registern 4002 bis 4005 umrangiert werden<\/p>\n
\n
\u00a0 \/\/ Analogwerte ausgeben<\/span>\n  \/\/ --------------------<\/span>\n  \/\/ Wert von der SPS<\/span>\n  I2AA1_WERT<\/span>[0] = mb.Hreg<\/span>(1); \u00a0\/\/ Holding-Register 1 = 40002 in der SPS<\/span>\n  I2AA1_WERT<\/span>[1] = mb.Hreg<\/span>(2); \u00a0\/\/ Holding-Register 2 = 40003 in der SPS<\/span>\n  I2AA1_WERT<\/span>[2] = mb.Hreg<\/span>(3); \u00a0\/\/ Holding-Register 3 = 40004 in der SPS<\/span>\n  I2AA1_WERT<\/span>[3] = mb.Hreg<\/span>(4); \u00a0\/\/ Holding-Register 4 = 40005 in der SPS<\/span>\n  \/\/ Werte zur Analogkarte schicken<\/span>\n  I2AA<\/span>(I2AA1_ADDR, I2AA1_WERT, I2AA1_OK);<\/pre>\n<\/div>\n
Software SIEMENS TIA-Portal<\/h2>\n
\"S7-1511\"<\/a>Als SPS habe ich eine SIEMENS SIMATIC S7-1511 CPU auf meinem Teststand.
Die soll jetzt als Modbus-TCP-Client die Werte vom Server lesen und schreiben.<\/p>\n
Eine Ausf\u00fchrliche Beschreibung der Modbus-Kommunikation gibt es als PDF-Dokument auf der SIEMENS Seite\u00a0 support.industry.siemens.com
Modbus\/TCP mit den Anweisungen MB_CLIENT und …<\/a><\/p>\n
Im Beispiel verwende ich drei Datenbausteine<\/p>\n
DB3 = DataWrite<\/h4>\n
Darin ist ein Array mit 5 WORD Variablen f\u00fcr das Holding-Register[0] .. [4] angelegt.<\/p>\n
\"\"<\/a><\/p>\n
DB3 = DataRead<\/h4>\n
Darin ist ein Array mit 6 WORD Variablen f\u00fcr die Reading-Register[0] .. [5] angelegt.<\/p>\n
\"\"<\/a><\/p>\n
DB100 = ModbusData<\/h4>\n
Hier sind die Verbindungsdaten und ein paar Variablen f\u00fcr den Status vom Funktionsbaustein MB_CLIENT definiert<\/p>\n
es m\u00fcssen zwei Strukturen mit dem UDT TCON_IP_V4 angelegt werden. Eine Struktur zum Lesen, eine Struktur zum Schreiben<\/p>\n
InterfaceID<\/strong> ist die Hardware-Kennung der lokalen Schnittstelle.
Die Hardware-Kennung finden Sie in der Ger\u00e4tekonfiguration der CPU. Markieren Sie die PROFINET-Schnittstelle – Eigenschaften –\u00a0 Systemkonstanten „Local_Profinet-Schnittstelle_1<\/p>\n
ID:<\/strong> \u00dcber den Parameter wird eine Verbindung innerhalb der CPU eindeutig identifiziert. Jede einzelne Instanz der Anweisung „MB_CLIENT“ sowie „MB_SERVER“ muss eine eindeutige ID verwenden.<\/p>\n
ConnectionType<\/strong> Verbindungstyp W\u00e4hlen Sie 11 (dezimal) f\u00fcr TCP. Andere Verbindungstypen sind nicht zul\u00e4ssig.<\/p>\n
ActiveEstablished<\/strong> Kennung f\u00fcr die Art des Verbindungsaufbaus. True: aktiver Verbindungsaufbau False: passiver Verbindungsaufbau<\/p>\n
RemoteAddress<\/strong> IP-Adresse des entfernten Verbindungspartners<\/p>\n
RemotePort<\/strong> Verwenden Sie die IP-Port-Nummer des Servers, zu dem der Client die Verbindung herstellt und \u00fcber das TCP\/IP-Protokoll kommuniziert<\/p>\n
LocalPort<\/strong> Port-Nummer des lokalen Verbindungspartners \u00a00= Beliebiger Port<\/p>\n\n\n\n\n
\"TCON_IP_V4<\/a><\/td>\nInterfaceID = 64 (Aus Hardware-Konfig)
ID = 2
ConnectionType = 11
ActiveEstablished = 1 (aktiver Verbindungsaufbau )
IP-Adresse = 192.168.1.7
RemotePort = 502
LocalPort = 0<\/td>\n<\/tr>\n
\"TCON_IP_V4<\/a><\/td>\nInterfaceID = 64 (Aus Hardware-Konfig)
ID = 1
ConnectionType = 11
ActiveEstablished = 1 (aktiver Verbindungsaufbau )
IP-Adresse = 192.168.1.7
RemotePort = 502
LocalPort = 0<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
FB1 ModbusTCP<\/h4>\n
\"\"<\/a><\/p>\n
\/\/ Input-Register vom Server lesen<\/span>\n#MB_READ(REQ := TRUE,\n    DISCONNECT :=FALSE<\/span>,    \/\/ Verbindung halten<\/span>\n    MB_MODE :=0,           \/\/ 0=Lesen<\/span>\n    MB_DATA_ADDR := 30001<\/span>, \/\/ Start bei Register 30001<\/span>\n    MB_DATA_LEN :=6,       \/\/ 6 Register auslesen<\/span>\n    DONE => \"ModbusData\".clientData.done_read<\/span>,\n    BUSY => \"ModbusData\".clientData.busy_read<\/span>,\n    ERROR => \"ModbusData\".clientData.error_read<\/span>,\n    STATUS => \"ModbusData\".clientData.status_read<\/span>,\n    MB_DATA_PTR := \"Date_Read\".InputRegister<\/span>,\n    CONNECT := \"ModbusData\".connectParamClient_read)<\/span>;\n\n\/\/ Holding-Register zum Server schreiben<\/span>\n#MB_WRITE(:= TRUE,\n    DISCONNECT:=FALSE,     \/\/ Verbindung halten<\/span>\n    MB_MODE:=1,            \/\/ 1=Schreiben<\/span>\n    MB_DATA_ADDR:=40001,   \/\/ Start bei Register 40001<\/span>\n    MB_DATA_LEN:=5,        \/\/ 5 Register auslesen<\/span>\n    DONE=>\"ModbusData\".clientData.done_write<\/span>,\n    BUSY=>\"ModbusData\".clientData.busy_write<\/span>,\n    ERROR=>\"ModbusData\".clientData.error_write<\/span>,\n    STATUS=>\"ModbusData\".clientData.status_write<\/span>,\n    MB_DATA_PTR:=\"Data_Write\".holdingRegister<\/span>,\n    CONNECT:=\"ModbusData\".connectParamClient_write)<\/span>;\n\n<\/pre>\n\n\n\n
\"\"<\/td>\nHier kann eine TIA-V17 Bibliothek mit den Bausteinen aus der obigen Beschreibung heruntergeladen werden
\n\tModbus-TCP TIA-V17 Library\t(1233 Downloads\t)\n<\/a>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Und hier das komplette Arduino-Programm<\/p>\n\n\n