Aufbau der Modbus-Telegramme und CRC
Gilt füralle EBEHAKO-Geräte mit Modbus RTU
Ein Modbus-RTU-Telegramm besteht aus Slave-Adresse, Function Code, Daten und einer CRC-16-Prüfsumme. Mit Function Code 3 lesen Sie Register, mit Function Code 6 schreiben Sie ein einzelnes Register. Welche Register es gibt, steht in der Modbus-Registerliste des jeweiligen Geräts im Download-Bereich.
Worum geht es?
Dieser Artikel richtet sich an alle, die eine eigene Software oder eine SPS an EBEHAKO-Geräte anbinden. Wenn Sie eine fertige Leittechnik oder ein Modbus-Testprogramm verwenden, übernimmt dieses den Telegrammaufbau. Dann müssen Sie nur Adresse, Baudrate, Parität und Registernummern einstellen.
Bei Modbus RTU fragt immer ein Master (Leittechnik, PC, SPS) an, und ein Slave (Regler, Messgerät) antwortet. Jedes Kästchen in den folgenden Tabellen ist ein Byte. Mehrbyte-Werte werden mit dem höherwertigen Byte (High) zuerst übertragen. Nur bei der CRC kommt das niederwertige Byte (Low) zuerst.
Register lesen – Function Code 3
Anfrage (Master → Slave):
| Slave-Adresse | Function Code | Register (High) | Register (Low) | Anzahl (High) | Anzahl (Low) | CRC (Low) | CRC (High) |
|---|---|---|---|---|---|---|---|
| 1 | 3 | 0 | 20 | 0 | 1 | 196 | 14 |
Antwort (Slave → Master):
| Slave-Adresse | Function Code | Anzahl Bytes | Daten (High) | Daten (Low) | … | CRC (Low) | CRC (High) |
|---|---|---|---|---|---|---|---|
| 1 | 3 | 2 | 0 | 233 | 121 | 202 |
Das Beispiel liest ein Register ab Registernummer 20 vom Gerät mit Adresse 1. Das Gerät antwortet mit 2 Datenbytes, also dem Wert 0 · 256 + 233 = 233. In Hexadezimalschreibweise:
Anfrage: 01 03 00 14 00 01 C4 0E
Antwort: 01 03 02 00 E9 79 CA
Die Anzahl der Bytes in der Antwort ist doppelt so groß wie die Anzahl der angefragten Register. Wie viele Register Sie höchstens auf einmal lesen dürfen, steht unter Baudraten und maximale Telegrammlänge.
Ein Register schreiben – Function Code 6
Mit Function Code 6 schreiben Sie einen 16-Bit-Wert in ein Register. Bei erfolgreicher Übertragung sendet der Slave die Anfrage unverändert zurück.
| Slave-Adresse | Function Code | Register (High) | Register (Low) | Daten (High) | Daten (Low) | CRC (Low) | CRC (High) |
|---|---|---|---|---|---|---|---|
| Adresse | 6 |
Die Antwort hat denselben Aufbau.
Die Regler nehmen Schreibbefehle je nach Protokoll nur an, wenn das Display im AUTOMODE steht (siehe
Protokolle: Modbus RTU, Modbus KTR und ASCII). Ist die Tastensperre
aktiv, können Register schreibgeschützt sein.
Mehrere Register schreiben – Function Code 16
Function Code 16 wird derzeit nur vom UCM-5 unterstützt.
Anfrage:
| Adresse | Function Code | Register (High) | Register (Low) | Anzahl (High) | Anzahl (Low) | Anzahl Bytes | Daten (High) | Daten (Low) | … | CRC (Low) | CRC (High) |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Adresse | 16 |
Antwort:
| Adresse | Function Code | Register (High) | Register (Low) | Anzahl (High) | Anzahl (Low) | CRC (Low) | CRC (High) |
|---|---|---|---|---|---|---|---|
| Adresse | 16 |
Die CRC-Prüfsumme
Am Ende jedes Telegramms steht eine 16-Bit-Prüfsumme (CRC-16/Modbus). Sie sichert die Übertragung zuverlässig ab:
- Der Sender berechnet die CRC über alle Bytes des Telegramms (ohne die CRC selbst) und hängt sie an, niederwertiges Byte zuerst.
- Der Empfänger berechnet die CRC über die empfangenen Bytes selbst und vergleicht. Stimmen die Werte nicht überein, wird das Telegramm verworfen und nicht beantwortet.
Berechnung: Startwert 0xFFFF, Polynom 0xA001 (bitweise gespiegelt), jedes Byte wird bitweise von rechts
verarbeitet.
- C
- Python
#include <stdint.h>
#include <stddef.h>
/* CRC-16/Modbus über len Bytes berechnen */
uint16_t modbus_crc(const uint8_t *data, size_t len)
{
uint16_t crc = 0xFFFF;
for (size_t i = 0; i < len; i++) { /* jedes Byte genau einmal */
crc ^= data[i];
for (int bit = 0; bit < 8; bit++) {
if (crc & 0x0001)
crc = (crc >> 1) ^ 0xA001;
else
crc >>= 1;
}
}
return crc; /* senden: zuerst crc & 0xFF, dann crc >> 8 */
}
def modbus_crc(data: bytes) -> int:
"""CRC-16/Modbus über alle Bytes berechnen."""
crc = 0xFFFF
for byte in data:
crc ^= byte
for _ in range(8):
crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
return crc
frame = bytes([0x01, 0x03, 0x00, 0x14, 0x00, 0x01])
crc = modbus_crc(frame)
telegramm = frame + bytes([crc & 0xFF, crc >> 8])
print(telegramm.hex(" ")) # 01 03 00 14 00 01 c4 0e
Die Schleife muss genau über die n Datenbytes laufen, also mit den Indizes 0 bis n − 1. In BASIC-Dialekten ist
For i = 0 To n ein Durchlauf zu viel. Richtig ist For i = 0 To n - 1.
Gut zu wissen
- Zwischen zwei Telegrammen muss eine Pause von mindestens 3,5 Zeichenlängen liegen, damit die Geräte den Beginn eines neuen Telegramms erkennen.
- Die Registerlisten der Regler finden Sie im Download-Bereich unter „Modbus“.