ESP32 Modbus Master TCP: 7 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:31

W tej klasie zaprogramujesz procesor ESP32 jako Modbus TCP Master.

Wykorzystamy dwa urządzenia, które zawierają ten procesor: Moduino ESP32 i Pycom. Oba urządzenia działają w środowisku MicroPython. Nasz Modbus Slave będzie komputerem PC z uruchomionym na nim oprogramowaniem symulatora Modbus.

Będziesz potrzebować:

• Moduino ESP32 lub Moduino Pycom (sprawdź tę stronę, aby dowiedzieć się więcej o urządzeniu Moduino ESP32 oraz o urządzeniu Pycom)
• PC z systemem operacyjnym Linux
• Port RS-232/RS-485 w komputerze lub konwerter USB na RS-232/RS-485

Krok 1: Pobierz i uruchom Modbus TCP Slave Simulator

Pobierz symulator Modbus Slave ze strony https://www.modbusdriver.com/diagslave.html. Następnie otwórz pobrane archiwum i rozpakuj wersję dla systemu operacyjnego Linux.

Uruchom program z konsoli z argumentem -p:

./diagslave -p

to port, na którym będzie działał serwer Modbus Slave. Dla protokołu Modbus domyślnie jest to 502, ale możesz użyć innego.

W Linuksie porty poniżej 1024 nie mogą być używane przez programy uruchamiane przez zwykłego użytkownika (nie z uprawnieniami roota).

Pamiętaj, jakiego portu używasz. Ta wartość będzie potrzebna później.

Krok 2: Przygotuj komputer do połączenia z urządzeniem

Do nawiązania połączenia z urządzeniem i wysłania do niego plików potrzebne będą programy.

Zainstaluj środowisko Python i pip (jeśli go nie masz):

apt-get zainstaluj python3

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

Zainstaluj picocom:

apt-get zainstaluj picocom

Ten program jest potrzebny do połączenia się z urządzeniem i wykonywania na nim poleceń. Zainstaluj mpfshell:

pip zainstaluj mpfshell

Ten program umożliwia wysyłanie plików do urządzenia.

Możesz również zainstalować go ze źródeł. Zapoznaj się z tą stroną:

Krok 3: Przygotuj urządzenie i połącz się z nim

Do podłączenia urządzenia Moduino lub Pycom do komputera potrzebny jest port lub konwerter RS-232/RS-485. Sprawdź wersję swojego urządzenia (jakiego typu portu używa) i znajdź odpowiedni port lub konwerter.

1. Podłącz urządzenie do komputera
2. Następnie podłącz do niego zasilanie

Podłącz urządzenie do komputera, a następnie podłącz do niego zasilanie. Możesz także podłączyć kabel ethernetowy do Moduino ESP32 (jeśli ma ten port).

Połączenie powinno być jak na zdjęciach powyżej

Znajdź ścieżkę do portu, który jest używany do podłączenia urządzenia. Może to być na przykład: /dev/ttyS1, /dev/ttyUSB0.

W przypadku konwerterów USB ścieżka będzie zawierać słowo USB.

Możesz połączyć się z urządzeniem za pomocą programu picocom:

picocom /dev/ttyUSB0 -b 115200

Wiersz poleceń urządzenia wygląda podobnie do jednego z poniższych obrazów.

Moduino ESP32: Zobacz tutaj

Moduino Pycom: Zobacz tutaj

Krok 4: Prześlij główną bibliotekę Modbus

github.com/pycom/pycom-modbus/Do komunikacji z Modbus Slave potrzebna jest odpowiednia biblioteka. Biblioteki dla Pycom nie są kompatybilne z Moduino. Sprawdź instrukcje, które są zgodne z Twoim urządzeniem.

Zamknij picocom przed wysłaniem plików: naciśnij Ctrl+A, a następnie Ctrl+X.

Biblioteka uModBus dla Moduino ESP32 bazuje na bibliotece pycom-modbus dla Moduino Pycom. Jest zmodyfikowany do pracy na zwykłym urządzeniu ESP32. Zawiera również dodatkowe metody close() dla klas łączników.

1) Moduino ESP32

Pobierz bibliotekę z https://github.com/techbase123/micropython-modbus. Rozpakuj archiwum i wyślij wszystkie 4 pliki do urządzenia Moduino.

Użyj mpfshell, aby je przesłać. Uruchom ten program w katalogu z tymi plikami.

Połącz się z urządzeniem, wykonując: TO

ttyUSB0 to nazwa portu szeregowego, do którego podłączone jest urządzenie.

Zmień katalog na /flash/lib za pomocą polecenia:

cd /flash/lib

Umieść wszystkie pliki z poleceniami:

umieść uModBusConst.py

wstaw uModBusFunctions.py wstaw uModBusTCP.py wstaw uModBusSerial.py

PRZYKŁAD

Następnie wyjdź z konsoli komendą exit i zrestartuj urządzenie przyciskiem Reset.

2) Moduino Pycom

Pobierz bibliotekę z https://github.com/pycom/pycom-modbus/. Rozpakuj archiwum i wyślij zawartość katalogu uModbus do urządzenia. Użyj mpfshell, aby je wgrać. Uruchom ten program w katalogu z tymi plikami.

Połącz się z urządzeniem, wykonując:

otwórz port USB0

ttyUSB0 to nazwa portu szeregowego, do którego podłączone jest urządzenie.

Zmień katalog na /flash/lib, utwórz katalog uModbus i wpisz go komendami:

cd /flash/libmd uModbus cd uModbus

Umieść wszystkie pliki z poleceniami:

wstaw const.py

umieścić functions.py umieścić tcp.py umieścić serial.py

Następnie wyjdź z konsoli komendą exit i zrestartuj urządzenie przyciskiem Reset.

PRZYKŁAD

Krok 5: Połącz się z siecią

Komendy do nawiązania połączenia różnią się między Moduino i Pycom.

Połącz się z urządzeniem za pomocą picocom, aby wykonać odpowiednie polecenia. Urządzenie Moduino można podłączyć do sieci przewodowo lub bezprzewodowo. Poniższe przykłady zakładają, że w Twojej sieci działa serwer DHCP.

W innym przypadku urządzenie nie otrzyma adresu IP. Obsługa WiFi jest dostępna w każdym Moduino. Port Ethernet jest opcją i nie wszystkie urządzenia go posiadają.

1) Moduino ESP32

Łączę się z Wi-Fi

Wykonaj następujące polecenia na urządzeniu:

z importu netWiFi netWiFiwifi = netWiFi(netWiFi. WIFI_STA, 'ESSID', 'PASS')wifi.start()

Zastąp ESSID nazwą swojej sieci WiFi, a PASS hasłem do niej.

Po pewnym czasie po wykonaniu start() powinieneś otrzymać adres IP, który został przypisany do Twojego urządzenia.

Podłączanie do sieci Ethernet

Podłącz urządzenie do sieci przewodowej za pomocą kabla Ethernet.

Następnie wykonaj następujące polecenia:

z importu netETH netETHeth = netETH()eth.start()

Po pewnym czasie po wykonaniu start() powinieneś otrzymać adres IP, który został przypisany do twojego urządzenia.

2) Moduino Pycom

Połącz się z Wi-Fi

Wykonaj następujące polecenia na urządzeniu:

z importu sieci WLANwlan = WLAN(mode=WLAN. STA) nets = wlan.scan() for net in nets:if net.ssid == 'ESSID': print('Znaleziono sieć!') wlan.connect(net.ssid, auth=(net.sec, 'PASS'), timeout=5000) gdy nie wlan.isconnected(): machine.idle() print('Połączenie WLAN powiodło się!') break

Zastąp ESSID nazwą swojej sieci WiFi, a PASS hasłem do niej.

Krok 6: Zainicjuj komunikację z Modbus Slave

Biblioteki Modbus Master są podobne dla obu urządzeń

Różnią się inicjalizacją.

1) Zainicjuj uModBus na Moduino ESP32

Wykonać:

z uModBusTCP importuj uModBusTCP jako TCP

2) Zainicjuj uModBus na Pycom

Wykonać:

z uModbus.tcp import TCP

Otwórz połączenie

Następnie otwórz połączenie z:

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

gdzie:

• IP - adres IP twojego komputera z symulatorem Modbus Slave
• PORT - port Modbus Slave
• 60 to limit czasu

Jeżeli podczas wykonywania poleceń odczytu/zapisu wystąpi następujący błąd: PRZYKŁAD

wykonać:

dla Moduino ESP32:

modbus.zamknij()

dla Moduino Pycom:

modbus._sock.close()

a następnie odtwórz połączenie:

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

Ważne jest, aby zamknąć gniazdo przed ponownym utworzeniem połączenia. Urządzenie ma ograniczoną ilość dostępnego połączenia z gniazdem.

Krok 7: Odczyt i zapis rejestrów

Modbus obsługuje kilka funkcji odczytu i zapisu rejestrów.

Biblioteka uModBus posiada metodę dla każdej funkcji:

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

Najpierw napiszmy kilka wartości.

1) Napisz cewki (funkcja: 5)

Zapisz 1 wartość do rejestru 200 z urządzenia podrzędnego 1:

modbus.write_single_coil(1, 200, 0xFF00)

Pierwszy argument dotyczy identyfikatora niewolnika, w naszym przypadku 1.

Drugi to numer rejestru, a this to wartość. Dla 1 musisz wpisać tutaj 0xFF00. Zapisz rejestr od 0 do 201 z urządzenia podrzędnego 1:

modbus.write_single_coil(1, 201, 0)

Ta metoda pozwala na zapisanie tylko wartości logicznych: 0 lub 1.

2) Zapis rejestrów (func: 6)

Teraz zapisz kilka wartości całkowitych do kilku rejestrów.

Zapisz podpisaną wartość 111 do rejestru 100 z urządzenia podrzędnego 1:

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

Pierwszy argument to identyfikator urządzenia podrzędnego, drugi numer rejestru, a trzeci to nowa wartość. Ostatni argument określa, czy wartość powinna być ustawiona jako liczba ze znakiem. Domyślna wartość to True. Nie musisz tego ustawiać.

Zapisz podpisaną wartość -457 do rejestru 101 z urządzenia podrzędnego 1:

modbus.write_single_register(1, 101, -457)

Zapisz wartość 50 bez znaku do rejestru 100 z urządzenia podrzędnego 3:

modbus.write_single_register(3, 100, 50, Fałsz)

Ta metoda umożliwia zapisywanie wartości całkowitych do pojedynczego rejestru.

Pojedynczy rejestr może zawierać 16-bitowe wartości.

Metoda zwraca True, jeśli wartość wejściowa jest prawidłowa, a False, jeśli nie. Wartość jest zapisywana, nawet jeśli jest nieprawidłowa (za duża dla rejestru)

3) Odczytaj cewki/wejścia dyskretne

Teraz przeczytajmy zapisane wartości logiczne. Aby odczytać rejestr za pomocą funkcji 1 read coil, wykonaj:

modbus.read_coils(slaveId, rejestr, liczba)[0:liczba]

Aby odczytać rejestr za pomocą funkcji 2 czytaj wejście dyskretne, wykonaj:

modbus.read_discrete_inputs(slaveId, rejestr, liczba)[0:liczba]

gdzie:

• slave-id - identyfikator wirtualnego urządzenia podrzędnego (symulator Slave akceptuje wszystkie ważne identyfikatory)
• register - numer rejestru do odczytu
• count - ilość rejestrów do odczytu (w obu miejscach wstaw żądaną ilość)

Te metody zwracają tablicę z wartościami logicznymi. Każda wartość odpowiada każdemu rejestrowi.

Fragment: [0:count] jest potrzebny, ponieważ ta metoda zwraca więcej wartości niż count. Zwraca zawsze ilość wartości podzielną przez 8. Dodatkowe wartości to False i nie odpowiadają żadnemu rejestrowi.

Przeczytaj nasze wartości logiczne obiema metodami:

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

Wynik będzie taki: PRZYKŁAD

Prawda odnosi się do 1 wartości, fałsz do 0.

4) Odczytaj rejestry

Teraz odczytaj wartości z rejestrów zapisanych funkcją 6.

Aby odczytać rejestry za pomocą funkcji 3 read hold registers, wykonaj:

modbus.read_holding_registers(slaveId, rejestr, liczba, podpisany=True)

Aby odczytać rejestry za pomocą funkcji 4 odczytać rejestry wejściowe, wykonaj:

modbus.read_input_registers(slaveId, rejestr, liczba, podpisany=True)

gdzie:

• slave-id - identyfikator wirtualnego urządzenia podrzędnego
• register - numer rejestru do odczytu
• count - ilość rejestrów do odczytu
• signed - wskazuje, czy odczytane wartości powinny być traktowane jako liczby ze znakiem, czy nie. Stan domyślny: Prawda

Wartość zwracana to krotka z pożądaną ilością rejestrów.

Odczytaj rejestry ustawione w poprzednim punkcie:

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)

Wyniki powinny wyglądać jak na tym zrzucie ekranu: PRZYKŁAD

W następnej lekcji dowiesz się, jak stworzyć Modbus RTU Master na urządzeniu z obsługą ESP32.