ESP32 Modbus Master TCP - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

In dieser Klasse programmieren Sie den ESP32-Prozessor als Modbus TCP-Master.

Wir werden zwei Geräte verwenden, die diesen Prozessor enthalten: Moduino ESP32 und Pycom. Beide Geräte laufen in einer MicroPytthon-Umgebung. Unser Modbus-Slave wird ein PC-Computer sein, auf dem die Modbus-Simulator-Software ausgeführt wird.

Du wirst brauchen:

• Moduino ESP32- oder Moduino Pycom-Gerät (auf dieser Website erfahren Sie mehr über das Moduino ESP32-Gerät und dies, um das Pycom-Gerät zu überprüfen)
• PC mit Linux-Betriebssystem
• RS-232/RS-485-Port in Ihrem Computer oder USB-zu-RS-232/RS-485-Konverter

Schritt 1: Laden Sie den Modbus TCP-Slave-Simulator herunter und starten Sie ihn

Laden Sie den Modbus-Slave-Simulator von https://www.modbusdriver.com/diagslave.html herunter. Öffnen Sie dann das heruntergeladene Archiv und entpacken Sie die Version für das Linux-Betriebssystem.

Führen Sie das Programm von der Konsole mit dem Argument -p aus:

./diagslave -p

ist ein Port, an dem der Modbus-Slave-Server arbeitet. Für das Modbus-Protokoll ist es standardmäßig 502, aber Sie können ein anderes verwenden.

In Linux können Ports unter 1024 nicht von Programmen verwendet werden, die von normalen Benutzern (nicht mit Root-Rechten) ausgeführt werden.

Denken Sie daran, welchen Port Sie verwenden. Dieser Wert wird später benötigt.

Schritt 2: Bereiten Sie Ihren Computer vor, um eine Verbindung zum Gerät herzustellen

Sie benötigen einige Programme, um eine Verbindung zum Gerät herzustellen und Dateien dorthin zu senden.

Installieren Sie die Python-Umgebung und pip (wenn Sie es nicht haben):

apt-get install python3

apt-get install python3-dev curl "https://bootstrap.pypa.io/get-pip.py" -o "get-pip.py" python3 get-pip.py

Picocom installieren:

apt-get install picocom

Dieses Programm wird benötigt, um eine Verbindung zum Gerät herzustellen und Befehle darauf auszuführen. Install mpfshell:

pip installiere mpfshell

Mit diesem Programm können Sie Dateien an das Gerät senden.

Sie können es auch aus Quellen installieren. Siehe diese Seite:

Schritt 3: Gerät vorbereiten und damit verbinden

Um ein Moduino- oder Pycom-Gerät an den PC anzuschließen, benötigen Sie einen RS-232/RS-485-Port oder einen Konverter. Überprüfen Sie die Version Ihres Geräts (welcher Porttyp es verwendet) und finden Sie den passenden Port oder Konverter.

1. Gerät mit PC verbinden
2. Dann Netzteil daran anschließen

Verbinden Sie das Gerät mit dem PC und schließen Sie dann die Stromversorgung an. Sie können auch ein Ethernet-Kabel an Moduino ESP32 anschließen (wenn es diesen Port hat).

Die Verbindung sollte wie auf den Fotos oben sein

Suchen Sie den Pfad für den Port, der für die Geräteverbindung verwendet wird. Dies kann zum Beispiel sein: /dev/ttyS1, /dev/ttyUSB0.

Bei USB-Konvertern enthält der Pfad das USB-Wort.

Sie können sich mit dem Picocom-Programm mit dem Gerät verbinden:

picocom /dev/ttyUSB0 -b 115200

Die Eingabeaufforderung des Geräts ähnelt einer dieser Abbildungen unten.

Moduino ESP32: Siehe hier

Moduino Pycom: Siehe hier

Schritt 4: Modbus-Masterbibliothek hochladen

github.com/pycom/pycom-modbus/Um mit dem Modbus-Slave zu kommunizieren, benötigen Sie eine entsprechende Bibliothek. Bibliotheken für Pycom sind nicht mit Moduino kompatibel. Überprüfen Sie die Anweisungen, die Ihrem Gerät entsprechen.

Schließen Sie picocom, bevor Sie Dateien senden: Drücken Sie die Tasten Strg+A und dann Strg+X.

Die uModBus-Bibliothek für Moduino ESP32 basiert auf der pycom-modbus-Bibliothek für Moduino Pycom. Es wurde modifiziert, um auf einem normalen ESP32-Gerät zu funktionieren. Es hat auch zusätzliche close()-Methoden für Connector-Klassen.

1) Moduino ESP32

Laden Sie die Bibliothek von https://github.com/techbase123/micropython-modbus herunter. Archiv entpacken und alle 4 Dateien an das Moduino-Gerät senden.

Verwenden Sie mpfshell, um sie hochzuladen. Führen Sie dieses Programm im Verzeichnis mit diesen Dateien aus.

Verbinden Sie sich mit dem Gerät, indem Sie Folgendes ausführen:

ttyUSB0 ist der Name des seriellen Ports, an den das Gerät angeschlossen ist.

Ändern Sie das Verzeichnis in /flash/lib mit dem Befehl:

cd /flash/lib

Setzen Sie alle Dateien mit Befehlen:

put uModBusConst.py

put uModBusFunctions.py put uModBusTCP.py put uModBusSerial.py

BEISPIEL

Beenden Sie dann die Konsole mit dem Befehl exit und starten Sie das Gerät mit der Reset-Taste neu.

2) Moduino Pycom

Laden Sie die Bibliothek von https://github.com/pycom/pycom-modbus/ herunter. Entpacken Sie das Archiv und senden Sie den Inhalt des uModbus-Verzeichnisses an das Gerät. Verwenden Sie mpfshell, um sie hochzuladen. Führen Sie dieses Programm im Verzeichnis mit diesen Dateien aus.

Verbinden Sie sich mit dem Gerät, indem Sie Folgendes ausführen:

ttyUSB0 öffnen

ttyUSB0 ist der Name des seriellen Ports, an den das Gerät angeschlossen ist.

Wechseln Sie in das Verzeichnis /flash/lib, erstellen Sie das uModbus-Verzeichnis und geben Sie es mit den Befehlen ein:

cd /flash/libmd uModbus cd uModbus

Setzen Sie alle Dateien mit Befehlen:

setze const.py

putfunctions.py put tcp.py put serial.py

Beenden Sie dann die Konsole mit dem Befehl exit und starten Sie das Gerät mit der Reset-Taste neu.

BEISPIEL

Schritt 5: Mit dem Netzwerk verbinden

Befehle zum Herstellen einer Verbindung unterscheiden sich zwischen Moduino und Pycom.

Verbinden Sie sich über picocom mit dem Gerät, um die entsprechenden Befehle auszuführen. Sie können das Moduino-Gerät drahtgebunden oder drahtlos mit dem Netzwerk verbinden. In den folgenden Beispielen wird davon ausgegangen, dass Ihr Netzwerk über einen funktionierenden DHCP-Server verfügt.

In anderen Fällen erhält das Gerät keine IP-Adresse. WiFi-Unterstützung ist in jedem Moduino verfügbar. Ethernet-Port ist eine Option und nicht alle Geräte haben sie.

1) Moduino ESP32

Mit WLAN verbinden

Führen Sie folgende Befehle auf dem Gerät aus:

aus netWiFi importieren netWiFiwifi = netWiFi(netWiFi. WIFI_STA, 'ESSID', 'PASS')wifi.start()

Ersetzen Sie ESSID durch den Namen Ihres WiFi-Netzwerks und PASS durch das Passwort davon.

Nach einiger Zeit nach der Ausführung von start() sollten Sie eine IP-Adresse erhalten, die Ihrem Gerät zugewiesen wurde.

Verbindung mit Ethernet-Netzwerk

Verbinden Sie das Gerät über ein Ethernet-Kabel mit dem kabelgebundenen Netzwerk.

Führen Sie dann folgende Befehle aus:

aus netETH importieren netETHeth = netETH()eth.start()

Nach einiger Zeit nach der Ausführung von start() sollten Sie die IP-Adresse erhalten, die Ihrem Gerät zugewiesen wurde.

2) Moduino Pycom

Mit WLAN verbinden

Führen Sie folgende Befehle auf dem Gerät aus:

aus dem Netzwerk importieren WLANwlan = WLAN(mode=WLAN. STA) nets = wlan.scan() für net in nets:if net.ssid == 'ESSID': print('Network found!') wlan.connect(net.ssid, auth=(net.sec, 'PASS'), timeout=5000) während nicht wlan.isconnected(): machine.idle() print('WLAN-Verbindung erfolgreich!') break

Ersetzen Sie ESSID durch den Namen Ihres WiFi-Netzwerks und PASS durch das Passwort davon.

Schritt 6: Initialisieren Sie die Kommunikation mit dem Modbus-Slave

Modbus-Master-Bibliotheken sind für beide Geräte ähnlich

Sie unterscheiden sich in der Initialisierung.

1) uModBus auf Moduino ESP32 initialisieren

Ausführen:

aus uModBusTCP importieren uModBusTCP als TCP

2) uModBus auf Pycom initialisieren

Ausführen:

aus uModbus.tcp importieren TCP

Verbindung öffnen

Dann Verbindung öffnen mit:

modbus=TCP('IP', PORT, 60)

wo:

• IP - IP-Adresse Ihres PCs mit Modbus-Slave-Simulator
• PORT - Port des Modbus Slave
• 60 ist eine Auszeit

Wenn beim Ausführen von Lese-/Schreibbefehlen folgender Fehler auftritt: BEISPIEL

ausführen:

für Moduino ESP32:

modbus.close()

für Moduino Pycom:

modbus._sock.close()

und dann Verbindung neu herstellen:

modbus=TCP('IP', PORT, 60)

Dies ist wichtig, um den Socket zu schließen, bevor die Verbindung neu erstellt wird.

Schritt 7: Register lesen und schreiben

Modbus unterstützt mehrere Funktionen zum Lesen und Schreiben von Registern.

Die uModBus-Bibliothek hat eine Methode für jede Funktion:

1. read_coils
2. read_discrete_inputs
3. read_holding_registers
4. read_input_registers
5. write_single_coil
6. write_single_register

Schreiben wir zunächst einige Werte.

1) Coils schreiben (Funktion: 5)

Schreiben Sie 1 Wert in das 200-Register von Slave 1:

modbus.write_single_coil(1, 200, 0xFF00)

Das erste Argument ist für die Slave-ID, in unserem Fall 1.

Die zweite ist die Registernummer und die dritte ein Wert. Für 1 müssen Sie hier 0xFF00 eingeben. 0 bis 201 Register von Slave 1 schreiben:

modbus.write_single_coil(1, 201, 0)

Mit dieser Methode können nur boolesche Werte geschrieben werden: 0 oder 1.

2) Register schreiben (Funktion: 6)

Schreiben Sie nun einige ganzzahlige Werte in mehrere Register.

Schreiben Sie den 111-Wert mit Vorzeichen in das Register 100 von Slave 1:

modbus.write_single_register(1, 100, 111, True)

Das erste Argument ist die Slave-ID, die zweite Registernummer und das dritte ist der neue Wert. Das letzte Argument definiert, ob der Wert als vorzeichenbehaftete Zahl gesetzt werden soll. Der Standardwert dafür ist True. Sie müssen es nicht einstellen.

Schreibe einen vorzeichenbehafteten -457-Wert in das 101-Register von Slave 1:

modbus.write_single_register(1, 101, -457)

Schreiben Sie nicht vorzeichenbehafteten 50-Wert in das 100-Register von Slave 3:

modbus.write_single_register(3, 100, 50, Falsch)

Diese Methode ermöglicht das Schreiben von ganzzahligen Werten in ein einzelnes Register.

Ein einzelnes Register kann 16-Bit-Werte enthalten.

Methode gibt True zurück, wenn der Eingabewert gültig ist, und False, wenn nicht. Wert wird geschrieben, auch wenn er ungültig ist (zu groß für Register)

3) Spulen/diskrete Eingänge lesen

Lässt jetzt geschriebene boolesche Werte lesen. Um das Register mit der Funktion 1 read Coil zu lesen, führen Sie Folgendes aus:

modbus.read_coils(slaveId, register, count)[0:count]

Um das Register mit der Funktion 2 Read Discrete Input zu lesen, führen Sie Folgendes aus:

modbus.read_discrete_inputs(slaveId, register, count)[0:count]

wo:

• slave-id - ID des virtuellen Slaves (Slave-Simulator akzeptiert alle gültigen IDs)
• register - Registernummer zum Lesen
• count - Anzahl der zu lesenden Register (gewünschte Anzahl an beiden Stellen eingeben)

Diese Methoden geben ein Array mit booleschen Werten zurück. Jeder Wert entspricht jedem Register.

Das Fragment: [0:count] wird benötigt, da diese Methode mehr Werte zurückgibt, als count. Es gibt immer eine durch 8 teilbare Anzahl von Werten zurück. Zusätzliche Werte sind False und entsprechen keinem Register.

Lesen Sie unsere booleschen Werte mit beiden Methoden:

modbus.read_coils(1, 200, 2)[0:2]modbus.read_discrete_inputs(1, 200, 2)[0:2]

Das Ergebnis sieht wie folgt aus: BEISPIEL

True bezieht sich auf 1 Wert, False auf 0.

4) Register lesen

Lesen Sie nun Werte aus Registern, die mit der 6-Funktion geschrieben wurden.

Um Register mit Funktion 3 Halteregister lesen zu lesen, führen Sie Folgendes aus:

modbus.read_holding_registers(slaveId, register, count, signed=True)

Um Register mit der Funktion 4 read input registers zu lesen, führen Sie Folgendes aus:

modbus.read_input_registers(slaveId, register, count, signed=True)

wo:

• slave-id - ID des virtuellen Slaves
• register - Registernummer zum Lesen
• count - Anzahl der zu lesenden Register
• Vorzeichen - gibt an, ob gelesene Werte als vorzeichenbehaftete Zahlen behandelt werden sollen oder nicht. Standardzustand: True

Der Rückgabewert ist ein Tupel mit der gewünschten Anzahl von Registern.

Lesen Sie die im vorherigen Punkt festgelegten Register:

modbus.read_holding_registers(1, 100, 2, True)modbus.read_input_registers(1, 100, 2, True)modbus.read_holding_registers(3, 100, 1, False)modbus.read_input_registers(3, 100, 1, False)

Die Ergebnisse sollten wie in diesem Screenshot aussehen: BEISPIEL

In der nächsten Lektion erfahren Sie, wie Sie einen Modbus RTU-Master auf einem ESP32-fähigen Gerät erstellen.