Spisu treści:
- Krok 1: Pobierz i uruchom Modbus TCP Slave Simulator
- Krok 2: Przygotuj komputer do połączenia z urządzeniem
- Krok 3: Przygotuj urządzenie i połącz się z nim
- Krok 4: Prześlij główną bibliotekę Modbus
- Krok 5: Połącz się z siecią
- Krok 6: Zainicjuj komunikację z Modbus Slave
- Krok 7: Odczyt i zapis rejestrów
Wideo: 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.
- Podłącz urządzenie do komputera
- 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:
- read_coils
- read_discrete_inputs
- read_holding_registers
- read_input_registers
- write_single_coil
- 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.
Zalecana:
Digistump i Modbus RTU: 6 kroków
Digistump i Modbus RTU: Ci, którzy widzieli moje instrukcje dotyczące komunikacji między Modbus RTU i Raspberry Pi, wiedzą, że planuję projekt automatyzacji szklarni. Zrobiłem 2 małe płytki PCB, które można umieścić w pudełku projektowym. Link do płytki PCB zawrze
Symulacja przetwornika temperatury Modbus (Labview + Raspberry Pi 3): 8 kroków
Symulacja Transmisor De Temperatura Modbus (Labview + Raspberry Pi 3): POST ESCRITO EN ESPAÑOLSe simuló un circuito transmisor de temperatura, el elemento primario (Sensor) fue implementado mediante un potenciometro el cual varia el voltaje de entrada. Para enviar la información del sensor (Elemento Secundario), si imp
Komunikacja Modbus TCP między Arduino a urządzeniami przemysłowymi: 3 kroki
Komunikacja Modbus TCP między Arduino a urządzeniami przemysłowymi: przemysłowy sposób sterowania płytą Arduino za pomocą przemysłowego interfejsu HMI i połączenia jej z siecią przemysłową za pomocą komunikacji Modbus TCP
ESP8266 Modbus Termostat z dotykiem: 5 kroków
ESP8266 Modbus Thermostat with Touch: Pokażę ci w tej instrukcji, jak zrobić dobrze wyglądający termostat z ekranem dotykowym z opcjonalną obsługą Modbus przez RS485 z ArduiTouch ESP i ESP8266 (NodeMCU lub Wemos D1 Mini)
Miernik PZEM-004 + ESP8266 i platforma IoT Node-RED i Modbus TCP/IP: 7 kroków
Miernik PZEM-004 + ESP8266 i Platforma IoT Node-RED i Modbus TCP/IP: Przy tej okazji zintegrujemy nasz licznik mocy czynnej lub zużycia energii elektrycznej, Pzem-004 - Peacefair z platformą integracyjną IoT Node-RED używaną w poprzednich tutorialach, użyjemy modułu ESP8266 skonfigurowanego jako Modbus TCP/IP slave, później