Modbus TCP/IP-protocol: alles wat u moet weten om uw PLC’s met de cloud te verbinden
Modbus TCP is het meest gebruikte protocol voor het verzamelen van PLC-gegevens in de Franse industrie. Het wordt al meer dan 40 jaar toegepast in tientallen miljoenen apparaten. Als u connectiviteit op afstand in uw projecten integreert, zult u ongetwijfeld met Modbus TCP te maken krijgen — dus is het raadzaam om het grondig te begrijpen.
Deze handleiding behandelt de belangrijkste aspecten voor een ontwikkelaar: geschiedenis, byte-voor-byte structuur, functiecodes, vergelijking met concurrerende protocollen, prestatieoptimalisatie, beveiliging en een volledig en werkend voorbeeld van Python-code.
1. Van Modbus RTU naar Modbus TCP: 45 jaar ontwikkeling
Het ontstaan van Modbus in 1979
Modbus werd in 1979 ontwikkeld door Modicon (inmiddels overgenomen door Schneider Electric) om de eerste programmeerbare logische controllers (PLC’s) van het type Modicon 084 met elkaar te laten communiceren. Het was een serieel protocol (RS-232 en later RS-485) met een master/slave-structuur, dat voor één enkel doel was ontworpen: het lezen en schrijven van numerieke waarden op veldapparatuur.
Eenvoud was het uitgangspunt bij het ontwerp:
- Geen netwerkadressering — alleen een slave-ID van 1 tot 247 op de bus
- Geen authenticatie — elke master kan elke slave ondervragen
- Geen automatische detectie — de lijst met slaves wordt handmatig geconfigureerd
- Geen beveiligingsmechanisme — het protocol gaat uit van een fysiek beveiligde omgeving
Modbus RTU (Remote Terminal Unit): compacte binaire versie voor RS-485. De gegevens worden binair verzonden, met een 16-bits CRC voor foutdetectie. Nog steeds zeer wijdverbreid bij veldinstrumenten (energiemeters, druksensoren, frequentieregelaars).
Modbus ASCII: ASCII-leesbare versie, voor RS-232-verbindingen. Minder efficiënt (2 bytes per gegevensbyte), verouderd in nieuwe installaties.
Modbus TCP: Ethernet zonder protocolrevolutie
Rond 1996-1999, toen Ethernet in fabrieken steeds gangbaarder werd, heeft Modbus TCP het protocol ingekapseld in TCP/IP-frames. De aanpassing was zeer nauwkeurig:
- Hetzelfde gegevensmodel (coils, discrete inputs, input registers, holding registers)
- Dezelfde functiecodes
- Dezelfde registeradressering
- Verwijdering van de CRC (TCP garandeert de integriteit)
- Toevoeging van een MBAP-header van 7 bytes voor het routeren en correleren van verzoeken
- Standaard TCP-poort: 502
Het voordeel: alle bestaande apparatuur die Modbus RTU ondersteunde, kon met minimale aanpassingen worden omgezet naar Modbus TCP. Het nadeel: de oorspronkelijke beveiligingslekken bleven bestaan.
2. Opbouw van een Modbus TCP-frame — analyse per byte
Overzicht van het raster
┌─────────────────────────────────────────────────────────────────────┐
│ Trame Modbus TCP │
├──────────────────────────────────────────┬──────────────────────────┤
│ MBAP Header (7 octets) │ PDU │
├──────────┬──────────┬──────────┬─────────┼────────────┬─────────────┤
│ Trans.ID │ Proto.ID │ Length │ Unit ID │ Func.Code │ Data │
│ 2 bytes │ 2 bytes │ 2 bytes │ 1 byte │ 1 byte │ n bytes │
└──────────┴──────────┴──────────┴─────────┴────────────┴─────────────┘
Analyse van de MBAP-header
Transactie-ID (2 bytes): Een door de klant vrij gekozen nummer, dat in het antwoord ongewijzigd wordt teruggestuurd. Hiermee kunnen de antwoorden aan de verzoeken worden gekoppeld in het geval van permanente verbindingen met meerdere lopende verzoeken. In de praktijk gebruiken de meeste clients een eenvoudige teller (00 01, 00 02, 00 03...) of een vaste identificatiecode (00 00) als ze in de sequentiële verzoek/antwoord-modus werken.
Protocol-ID (2 bytes):
Voor Modbus is dit altijd 00 00. Deze constante is bedoeld om een eventuele uitbreiding naar andere protocollen via dezelfde poort mogelijk te maken, maar is nog nooit gebruikt.
Lengte (2 bytes):
Aantal bytes dat volgt, in big-endian. Omvat de Unit ID en de PDU, maar niet de eerste 4 bytes van de MBAP-header. Voor een FC=03-verzoek met 10 registers: 6 bytes (1 Unit ID + 1 FC + 2 adressen + 2 counts) → 00 06.
Unit Identifier (1 byte): Identificatiecode van de Modbus-slave. Bij rechtstreeks aangesloten PLC’s (S7-1200 met MB_SERVER, M340 met geïntegreerde Modbus-server) is de waarde doorgaans 1 of 255. Bij Modbus RTU→TCP-gateways komt deze identificatiecode overeen met het adres van de RTU-slave op de RS-485-bus.
Analyse van een volledig FC=03-verzoek
10 holdingregisters uitlezen vanaf adres 100 (bijv.: %MW100 op Schneider M340):
Requête client (hex) : 00 01 00 00 00 06 FF 03 00 64 00 0A
Décodage byte par byte :
00 01 → Transaction ID = 1
00 00 → Protocol ID = 0 (Modbus standard)
00 06 → Length = 6 (Unit ID + FC + 2 adresse + 2 count)
FF → Unit ID = 255 (0xFF = CPU locale M340)
03 → Function Code = Read Holding Registers
00 64 → Starting Address = 100 (0x0064 en big-endian)
00 0A → Quantity = 10 registres (0x000A)
Réponse automate (hex) : 00 01 00 00 00 17 FF 03 14 [20 octets]
Décodage :
00 01 → Transaction ID = 1 (même que la requête — corrélation)
00 00 → Protocol ID = 0
00 17 → Length = 23 (1 UID + 1 FC + 1 ByteCount + 20 données)
FF → Unit ID = 255
03 → Function Code = 3 (confirme que c'est une réponse normale)
14 → Byte Count = 20 (10 registres × 2 octets = 0x14 hex)
[suivi de 20 octets de données — 10 valeurs uint16 big-endian]
Foutcodes (foutmeldingen)
Wanneer de automaat een verzoek niet kan verwerken, geeft hij een uitzonderingscode terug:
Réponse exception (hex) : 00 01 00 00 00 03 FF 83 02
83 → FC + 0x80 = 3 + 128 = 131 → indique une réponse d'exception sur FC=3
02 → Exception code : Illegal Data Address
| Code | Naam | Betekenis | Veelvoorkomende oorzaak |
|---|---|---|---|
| 01 | Illegal Function | Niet-ondersteunde FC | De PLC ondersteunt deze FC niet |
| 02 | Illegal Data Address | Adres buiten bereik | Register > limiet PLC |
| 03 | Illegal Data Value | Ongeldige gegevenswaarde | Telling > 125 (FC=03) |
| 04 | Server Device Failure | Interne fout | Modbus-server niet geïnitialiseerd |
| 05 | Acknowledge | Langdurige verwerking bezig | Komt in de praktijk zelden voor |
| 06 | Server Device Busy | Server bezet | Te veel gelijktijdige verbindingen |
| 0A | Gateway Path Unavailable | Gateway-pad niet beschikbaar | RTU-slave niet bereikbaar |
| 0B | Gateway Target Device Failed | Slave reageert niet | RTU-slave uitgeschakeld of defect |
3. De functiecodes in detail
FC=01 en FC=02 — Bits uitlezen
FC=01 : Read Coils → bits de sortie (écriture autorisée)
FC=02 : Read Discrete Inputs → bits d'entrée (lecture seule)
Requête : FC AddrH AddrL QuantH QuantL
01 00 00 00 00 00 10 (lecture 16 coils depuis @0)
Réponse : FC ByteCount Coil_Data
01 02 [2 bytes = 16 bits d'état]
Note : les coils sont packés en bits, LSB first.
Byte1 bit0 = Coil@0, Byte1 bit1 = Coil@1, etc.
FC=03 — Read Holding Registers (meest gebruikt)
Lezen en schrijven van 16-bits registers. Limiet: maximaal 125 registers per verzoek.
FC=04 — Invoerregisters lezen
Hetzelfde als FC=03, maar dan voor de „invoer”-registers (alleen-lezen). Op de Schneider M340 komt dit overeen met de %IW. Op de meeste PLC's wordt dit weinig gebruikt, omdat de analoge meetwaarden worden gekopieerd naar de %MW (Holding Registers).
FC=06 en FC=16 — Registers schrijven
FC=06 : Write Single Register
Requête : FC AddrH AddrL ValueH ValueL
06 00 64 00 64 01 F4 (écriture 500 à l'adresse 100)
FC=16 : Write Multiple Registers (jusqu'à 123 registres par requête)
Requête : FC AddrH AddrL CountH CountL ByteCount Values...
10 00 64 00 05 01 2C [données]
Let op bij het schrijven (FC=06, FC=16): schrijf alleen registers als u zeker bent van de adressering en de gevolgen voor het PLC-programma. Het schrijven naar een instelregister verandert onmiddellijk het gedrag van het proces. Test altijd op een ontwikkelings-PLC of een PLC buiten de productieomgeving voordat u de wijzigingen implementeert.
4. Modbus TCP vs OPC-UA vs MQTT: welk protocol past bij uw architectuur?
Deze drie protocollen bestaan naast elkaar in moderne IIoT-architecturen. Ze bedienen verschillende lagen en staan niet in directe concurrentie met elkaar.
| Criterium | Modbus TCP | OPC-UA | MQTT |
|---|---|---|---|
| Oorsprong | 1979 (RTU), ~1996 (TCP) | 2008 | 1999 |
| Model | Client/Server (polling) | Client/server + Pub/Sub | Pub/Sub (broker) |
| Laag | Communicatie op het veld | Interoperabiliteit tussen systemen | IoT/cloud-transport |
| Ingebouwde beveiliging | Geen | TLS + authenticatie via certificaat | TLS + authenticatie |
| CPU-belasting PLC | Zeer laag | Hoog | Laag tot gemiddeld |
| Oudere PLC's | Universeel (40 jaar) | Alleen moderne PLC's | Via gateway |
| Automatische detectie | Nee | Ja (OPC-namespace) | Nee |
| Gestructureerde gegevens | Nee (platte registers) | Ja (typen, structuren, arrays) | Ja (JSON/CBOR) |
| Latentie | Laag (polling) | Zeer laag (pub/sub) | Zeer laag |
Hoe maak je een keuze?
Gebruik Modbus TCP als:
- De PLC Modbus TCP ondersteunt (Siemens S7-1200, Schneider M340/M221/M241, Wago, Allen-Bradley...)
- U eenvoudige meetwaarden (16-bits registers) moet verzamelen
- De eenvoud van de configuratie belangrijker is dan de uitgebreidheid van het gegevensmodel
Gebruik OPC-UA als:
- De PLC OPC-UA-server native ondersteunt (S7-1500, B&R, Beckhoff, recente versie van CODESYS 3.x)
- U complexe variabelen moet monitoren (structuren, arrays, aangepaste typen)
- Interoperabiliteit met andere SCADA- of MES-systemen een vereiste is
Gebruik MQTT voor cloudtransport als:
- U beschikt over een gateway (zoals Eziwan) die gegevens via Modbus/OPC-UA verzamelt en via MQTT publiceert
- U een schaalbare pub/sub-architectuur nodig hebt voor duizenden meetpunten
De doelarchitectuur voor de IIoT-cloud:
[Automate] ──Modbus TCP / OPC-UA──→ [Gateway] ──MQTT over TLS──→ [Cloud]
De gateway zet gegevens om en verzendt ze. Hij vormt de brug tussen de OT-wereld (Modbus/OPC-UA) en de cloudwereld (MQTT/REST).
5. Modbus TCP-beveiliging: het probleem en de oplossingen
Het volledig ontbreken van authenticatie
Modbus TCP beschikt niet over ingebouwde beveiligingsmechanismen:
- Geen authenticatie: iedereen op het netwerk kan lezen en schrijven
- Geen versleuteling: de gegevens zijn in leesbare vorm (leesbaar met Wireshark)
- Geen autorisatie: er is geen onderscheid tussen lees- en schrijfrechten per gebruiker
Praktisch gevolg: als uw PLC via internet toegankelijk is (poort 502 open), is deze volledig kwetsbaar. Als iemand verbinding maakt met uw OT-netwerk (fysiek of via een beveiligingslek), kan hij alle registers lezen en wijzigen.
Mogelijke antwoorden
Netwerksegmentatie (primaire maatregel): Beperk het Modbus TCP-verkeer tot een geïsoleerd OT-netwerk. De Eziwan-gateway bevindt zich in dit OT-netwerk; de communicatie met de cloud verloopt via een VPN-tunnel, niet via poort 502.
IP-filtering op de PLC (secundaire maatregel): Sommige recentere PLC’s (Schneider M340 firmware ≥ 2.60, Siemens S7-1200 firmware V4.x met FIREWALL-functies) ondersteunen IP-filtering: alleen het IP-adres van de Eziwan-gateway mag verbinding maken via poort 502.
Modbus Security (geavanceerde maatregel): De Modbus Organization heeft in 2018 een uitbreiding genaamd "Modbus Security" (TLS-transport voor Modbus TCP) op poort 802 gepubliceerd. Deze uitbreiding wordt nog niet op grote schaal ondersteund door de PLC's op de markt, maar is wel beschikbaar op bepaalde recentere apparaten.
6. Optimalisatie van de inzamelprestaties
Het bundelen van verzoeken (batching)
De gouden regel: leesbewerkingen groeperen in aaneengesloten blokken. Het lezen van 100 aaneengesloten registers in één query is veel efficiënter dan 100 afzonderlijke queries van elk één register:
Configuration inefficace (100 requêtes) :
Lire %MW0 → 1 requête (2 octets de données)
Lire %MW50 → 1 requête
Lire %MW99 → 1 requête
... 97 requêtes supplémentaires ...
Latence totale : 100 × (aller-retour réseau) ≈ 100 × 5ms = 500ms
Configuration optimisée (1 requête) :
Lire %MW0 à %MW99 → 1 requête (200 octets de données)
Latence totale : 1 × 5ms = 5ms
De Eziwan-gateway groepeert de geconfigureerde variabelen automatisch in aaneengesloten bereiken. Om deze groepering optimaal te benutten, dient u uw bewakingsvariabelen in aangrenzende geheugengebieden te ordenen.
Gevolgen voor de PLC-cyclus
Elk ontvangen Modbus TCP-verzoek wordt door de PLC aan het einde van de programmacyclus verwerkt. Bij een M340 met een cyclus van 10 ms kunnen 10 gelijktijdige Modbus-verzoeken de cyclus met 1 tot 3 ms verlengen.
Aanbeveling: bij toepassingen met realtime-eisen mag er niet meer dan 1 Modbus-verzoek per PLC-cyclus worden verzonden. Verlaag de pollingfrequentie als de cyclus langer duurt.
7. Volledig voorbeeld van Python-code met pymodbus
"""
Collecte Modbus TCP industrielle avec gestion d'erreurs robuste
Compatible Schneider M340, Siemens S7-1200, Wago, Allen-Bradley...
Testé avec pymodbus >= 3.0
Installation :
pip install pymodbus loguru
"""
from pymodbus.client import ModbusTcpClient
from pymodbus.exceptions import ModbusException, ConnectionException
from loguru import logger
import struct
import time
from dataclasses import dataclass
from typing import Optional
# ─── Configuration ────────────────────────────────────────────────────────────
HOST = "192.168.1.20" # IP automate Schneider M340
PORT = 502 # Port Modbus TCP
UNIT_ID = 255 # 255 pour CPU locale M340, 1 pour S7-1200
TIMEOUT = 3 # Timeout en secondes
RETRIES = 3 # Nombre de tentatives avant abandon
# ─── Structure de données ─────────────────────────────────────────────────────
@dataclass
class VariablesProcess:
temperature_c: float = 0.0
debit_lmin: int = 0
pression_bar: float = 0.0
pompe_1_marche: bool = False
pompe_2_marche: bool = False
code_defaut: int = 0
compteur_production: int = 0
timestamp: float = 0.0
# ─── Client Modbus avec reconnexion automatique ───────────────────────────────
class ModbusCollecteur:
"""Collecteur Modbus TCP avec gestion de reconnexion et retry."""
def __init__(self, host: str, port: int = 502, unit_id: int = 1):
self.host = host
self.port = port
self.unit_id = unit_id
self.client: Optional[ModbusTcpClient] = None
self._connexions_ok = 0
self._connexions_echec = 0
def connecter(self) -> bool:
"""Établit la connexion TCP vers l'automate."""
try:
self.client = ModbusTcpClient(
self.host,
port=self.port,
timeout=TIMEOUT,
retries=1, # Retries gérés par notre code
reconnect_delay=0, # Pas de reconnexion automatique
)
if self.client.connect():
self._connexions_ok += 1
logger.info(f"Connecté à {self.host}:{self.port}")
return True
else:
self._connexions_echec += 1
logger.warning(f"Connexion refusée par {self.host}:{self.port}")
return False
except Exception as e:
logger.error(f"Erreur connexion : {e}")
return False
def deconnecter(self):
if self.client:
self.client.close()
self.client = None
def lire_holding_registers(
self, adresse: int, count: int
) -> Optional[list[int]]:
"""Lit des registres avec retry automatique."""
for tentative in range(1, RETRIES + 1):
try:
if not self.client or not self.client.is_socket_open():
if not self.connecter():
time.sleep(1)
continue
result = self.client.read_holding_registers(
address=adresse, count=count, slave=self.unit_id
)
if result.isError():
exception_code = getattr(result, 'exception_code', '?')
logger.warning(
f"Erreur Modbus addr={adresse} count={count} "
f"exception_code={exception_code}"
)
# Exception 04 (server busy) → attendre avant retry
if exception_code == 6:
time.sleep(0.5)
self.deconnecter()
continue
return result.registers
except ConnectionException:
logger.warning(f"Connexion perdue (tentative {tentative}/{RETRIES})")
self.deconnecter()
time.sleep(0.5)
except Exception as e:
logger.error(f"Erreur inattendue : {e}")
self.deconnecter()
time.sleep(1)
logger.error(f"Échec lecture après {RETRIES} tentatives — addr={adresse}")
return None
@staticmethod
def registres_to_float32_abcd(reg_high: int, reg_low: int) -> float:
"""Décode 2 registres 16-bit en float32 IEEE754 big-endian (ABCD)."""
raw = struct.pack(">HH", reg_high, reg_low)
return struct.unpack(">f", raw)[0]
@staticmethod
def registres_to_int32(reg_high: int, reg_low: int) -> int:
"""Décode 2 registres en entier 32-bit signé big-endian."""
raw = struct.pack(">HH", reg_high, reg_low)
return struct.unpack(">i", raw)[0]
# ─── Lecture des variables process ───────────────────────────────────────────
def lire_variables(collecteur: ModbusCollecteur) -> Optional[VariablesProcess]:
"""
Lecture optimisée : 1 seule requête Modbus pour toutes les variables.
Plan mémoire (M340 EcoStruxure) :
%MW100 : Temperature (int16, ×0.1 → °C)
%MW101 : Débit (int16, L/min)
%MW102-103 : Pression (float32 ABCD, bar)
%MW104 : États machine (bits 0-7)
%MW105 : Code défaut actif
%MW106-107 : Compteur production (int32)
"""
# 1 requête pour %MW100 à %MW107 (8 registres)
registres = collecteur.lire_holding_registers(adresse=100, count=8)
if registres is None:
return None
vars_process = VariablesProcess(
temperature_c = registres[0] * 0.1, # %MW100
debit_lmin = registres[1], # %MW101
pression_bar = ModbusCollecteur.registres_to_float32_abcd( # %MW102+103
registres[2], registres[3]),
pompe_1_marche = bool(registres[4] & 0x0001), # %MW104 bit0
pompe_2_marche = bool(registres[4] & 0x0002), # %MW104 bit1
code_defaut = registres[5], # %MW105
compteur_production = ModbusCollecteur.registres_to_int32( # %MW106+107
registres[6], registres[7]),
timestamp = time.time(),
)
return vars_process
# ─── Boucle principale ────────────────────────────────────────────────────────
def main():
collecteur = ModbusCollecteur(HOST, PORT, UNIT_ID)
INTERVALLE = 5 # secondes entre chaque collecte
logger.info(f"Démarrage collecte Modbus TCP — {HOST}:{PORT} — cycle {INTERVALLE}s")
while True:
try:
vars_process = lire_variables(collecteur)
if vars_process:
logger.info(
f"T={vars_process.temperature_c:.1f}°C "
f"Q={vars_process.debit_lmin}L/min "
f"P={vars_process.pression_bar:.2f}bar "
f"P1={'ON' if vars_process.pompe_1_marche else 'OFF'} "
f"Défaut={vars_process.code_defaut}"
)
# Ici : publier via MQTT, API REST, ou base time-series
# mqtt_client.publish("usine/ligne3/variables", vars_process)
else:
logger.warning("Collecte échouée — attente 10s avant retry")
time.sleep(10)
continue
time.sleep(INTERVALLE)
except KeyboardInterrupt:
logger.info("Arrêt demandé.")
collecteur.deconnecter()
break
if __name__ == "__main__":
main()
Deze code illustreert de aanbevolen werkwijzen voor het verzamelen van Modbus TCP-gegevens in Python: het bundelen van uitlezingen, het afhandelen van uitzonderingen, automatisch opnieuw verbinden en het decoderen van complexe typen. In de productieomgeving ondersteunt de Eziwan-gateway al deze functies standaard — zonder dat er ter plaatse een Python-script nodig is.
Veelgestelde vragen — Modbus TCP/IP-protocol
Waarom is de Modbus TCP-poort 502 en niet een standaardpoort zoals 80 of 443?
Poort 502 is officieel door de IANA (Internet Assigned Numbers Authority) aan Modbus toegewezen bij de standaardisatie van Modbus TCP in de jaren negentig. Er was toen geen reden om bestaande IT-applicatiepoorten te hergebruiken. Het is een geregistreerde poort (< 1024), dus voor het gebruik ervan als server zijn root-rechten op Linux vereist — iets wat industriële firmware standaard ondersteunt.
Wat is het maximum aantal registers dat in één FC=03-verzoek kan worden gelezen?
De limiet bedraagt 125 registers per FC=03-verzoek (Read Holding Registers), zoals vastgelegd in de officiële Modbus-specificatie. Dit komt neer op maximaal 250 bytes aan bruikbare gegevens per verzoek. Voor FC=16 (Write Multiple Registers) geldt een limiet van 123 registers per verzoek. De Eziwan-gateway zorgt automatisch voor de opsplitsing als een aangevraagd bereik deze limieten overschrijdt.
Ondersteunt Modbus TCP meerdere gelijktijdige clientverbindingen?
Ja, maar het is de PLC die de limiet bepaalt. De Schneider M340 ondersteunt maximaal 16 gelijktijdige verbindingen, de Siemens S7-1200 maximaal 8 (via MB_SERVER). Bij meer dan dat geeft de PLC een uitzondering 06 (Server Busy) terug. In de praktijk komen een verzamelgateway + een diagnosetool + een lokaal SCADA-systeem al snel uit op 3 gelijktijdige verbindingen — dit moet in de gaten worden gehouden.
Kan Modbus TCP worden versleuteld?
De standaard Modbus TCP (poort 502) is niet versleuteld. Sinds 2018 bestaat er een uitbreiding genaamd „Modbus Security” op poort 802 met TLS, maar deze wordt door de huidige PLC’s zelden ondersteund. De praktische oplossing is om Modbus TCP te beperken tot een geïsoleerd OT-netwerk en alle communicatie naar buiten te laten verlopen via een versleutelde VPN-tunnel (zoals OpenVPN van Eziwan) — de versleuteling wordt verzorgd door de transportlaag, niet door Modbus zelf.
Is pymodbus de enige Python-bibliotheek voor Modbus TCP?
Nee. De belangrijkste alternatieven zijn minimalmodbus (eenvoudiger voor Modbus RTU), umodbus (lichtgewicht, neemt weinig geheugen in beslag) en pyModbusTCP (puur TCP, zonder afhankelijkheden). Voor industriële projecten in Python blijft pymodbus >= 3.0 de meest complete keuze, met uitzonderingsafhandeling, herverbinding en ondersteuning voor beide modi (RTU en TCP).
Hoe kun je een Modbus TCP-communicatie debuggen zonder toegang tot de PLC?
Gebruik Modbus Slave (Windows) als lokale PLC-simulator, of diagslave (opdrachtregel, platformonafhankelijk). Deze tools simuleren een Modbus TCP-server die reageert op configureerbare adressen. Ideaal om een gegevensverzamelingsconfiguratie te testen zonder het risico te lopen een PLC in productie te beïnvloeden.
Uw PLC ondersteunt Modbus TCP, maar u weet niet zeker of dit compatibel is met uw firmwareversie?
Controleer of uw besturingsunit compatibel is →
Zie ook: Modbus TCP met een Schneider M340 en de Siemens S7-documentatie voor specifieke configuraties.
