ESP32 Modbus Master TCP: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În această clasă, veți programa procesorul ESP32 pentru a fi Modbus TCP Master.

Vom folosi două dispozitive, care conțin acest procesor: Moduino ESP32 și Pycom. Ambele dispozitive rulează în mediul MicroPytthon. Modbus Slave va fi un computer PC cu software-ul Modbus simulator care rulează pe acesta.

Vei avea nevoie:

• Dispozitiv Moduino ESP32 sau Moduino Pycom (consultați acest site web pentru a afla mai multe despre dispozitivul Moduino ESP32 și acest lucru pentru a verifica dispozitivul Pycom)
• PC cu sistem de operare Linux
• Portul RS-232 / RS-485 din computer sau convertorul USB la RS-232 / RS-485

Pasul 1: Descărcați și porniți Modbus TCP Slave Simulator

Descărcați Modbus Slave simulator de pe https://www.modbusdriver.com/diagslave.html. Apoi deschideți arhiva descărcată și descărcați versiunea pentru sistemul de operare Linux.

Rulați programul de pe consolă cu argumentul -p:

./diagslave -p

este un port unde va funcționa serverul Modbus Slave. Pentru protocolul Modbus este implicit 502, dar puteți utiliza altul.

În porturile Linux sub 1024 nu pot fi utilizate de programele rulate de la un utilizator obișnuit (nu privilegii de root).

Amintiți-vă ce port utilizați. Această valoare va fi necesară mai târziu.

Pasul 2: Pregătiți computerul pentru a vă conecta la dispozitiv

Veți avea nevoie de unele programe pentru a vă conecta la dispozitiv și a trimite fișiere către acesta.

Instalați mediul Python și pip (dacă nu aveți):

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

Instalați picocom:

apt-get install picocom

Acest program este necesar pentru a vă conecta la dispozitiv și a executa comenzi pe acesta. Instalați mpfshell:

pip instalează mpfshell

Acest program vă permite să trimiteți fișiere pe dispozitiv.

Puteți instala, de asemenea, surse din formular. Consultați această pagină:

Pasul 3: Pregătiți dispozitivul și conectați-vă la acesta

Pentru a conecta dispozitivul Moduino sau Pycom la computer, aveți nevoie de port sau convertor RS-232 / RS-485. Verificați versiunea dispozitivului dvs. (ce tip de port utilizează) și găsiți portul sau convertorul adecvat.

1. Conectați dispozitivul la computer
2. Apoi conectați sursa de alimentare la acesta

Conectați dispozitivul la computer și apoi conectați sursa de alimentare la acesta. De asemenea, puteți conecta cablul Ethernet la Moduino ESP32 (dacă are acel port).

Conexiunea ar trebui să fie ca în fotografiile de mai sus

Găsiți calea pentru port, care este utilizată pentru conectarea dispozitivului. Poate fi de exemplu: / dev / ttyS1, / dev / ttyUSB0.

Pentru convertoarele USB, calea va conține cuvânt USB.

Vă puteți conecta la dispozitiv cu programul picocom:

picocom / dev / ttyUSB0 -b 115200

Invitația de comandă a dispozitivului arată similar cu una dintre aceste imagini de mai jos.

Moduino ESP32: Vezi aici

Moduino Pycom: Vezi aici

Pasul 4: Încărcați biblioteca principală Modbus

github.com/pycom/pycom-modbus/ Pentru a comunica cu Modbus Slave aveți nevoie de o bibliotecă adecvată. Bibliotecile pentru Pycom nu sunt compatibile cu Moduino. Verificați instrucțiunile care corespund dispozitivului dvs.

Închideți picocom înainte de a trimite fișiere: apăsați Ctrl + A și apoi tastele Ctrl + X.

Biblioteca uModBus pentru Moduino ESP32 se bazează pe biblioteca pycom-modbus pentru Moduino Pycom. Este modificat pentru a funcționa pe dispozitivul ESP32 obișnuit. De asemenea, are metode close () suplimentare pentru clasele de conectori.

1) Moduino ESP32

Descărcați biblioteca de la https://github.com/techbase123/micropython-modbus. Despachetați arhiva și trimiteți toate cele 4 fișiere pe dispozitivul Moduino.

Utilizați mpfshell pentru a le încărca. Rulați acest program în directorul cu acele fișiere.

Conectați-vă la dispozitiv executând: ACEST

ttyUSB0 este un nume al portului serial la care este conectat dispozitivul.

Schimbați directorul în / flash / lib cu comanda:

cd / flash / lib

Puneți toate fișierele cu comenzi:

pune uModBusConst.py

pune uModBusFunctions.py pune uModBusTCP.py pune uModBusSerial.py

EXEMPLU

Apoi, ieșiți din consolă cu comanda de ieșire și reporniți dispozitivul cu butonul Reset.

2) Moduino Pycom

Descărcați biblioteca de la https://github.com/pycom/pycom-modbus/. Despachetați arhiva și trimiteți conținutul directorului uModbus către dispozitiv. Utilizați mpfshell pentru a le încărca. Rulați acest program în directorul cu acele fișiere.

Conectați-vă la dispozitiv executând:

deschide ttyUSB0

ttyUSB0 este un nume al portului serial la care este conectat dispozitivul.

Schimbați directorul în / flash / lib, creați directorul uModbus și introduceți-l cu comenzi:

cd / flash / libmd uModbus cd uModbus

Puneți toate fișierele cu comenzi:

pune const.py

pune funcții.py pune tcp.py pune serial.py

Apoi, ieșiți din consolă cu comanda de ieșire și reporniți dispozitivul cu butonul Reset.

EXEMPLU

Pasul 5: Conectați-vă la rețea

Comenzile pentru stabilirea conexiunii diferă între Moduino și Pycom.

Conectați-vă la dispozitiv cu picocom pentru a executa comenzile corespunzătoare. Puteți conecta dispozitivul Moduino la rețea prin cablu sau fără fir. Următoarele exemple presupun că rețeaua dvs. are un server DHCP funcțional.

În alt caz, dispozitivul nu va primi adresa IP. Suportul Wi-Fi este disponibil în fiecare Moduino. Portul Ethernet este o opțiune și nu toate dispozitivele îl au.

1) Moduino ESP32

Conectarea la WiFi

Executați următoarele comenzi pe dispozitiv:

din import netWiFi netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

Înlocuiți ESSID cu numele rețelei dvs. WiFi și PASS cu parola acestuia.

După ceva timp după executarea start (), ar trebui să obțineți o adresă IP care a fost atribuită dispozitivului dvs.

Conectarea la rețeaua Ethernet

Conectați dispozitivul la rețeaua cu fir cu ajutorul unui cablu Ethernet.

Apoi executați următoarele comenzi:

din import netETH netETHeth = netETH () eth.start ()

După ceva timp după executarea start (), ar trebui să obțineți adresa IP care a fost atribuită dispozitivului dvs.

2) Moduino Pycom

Conectați-vă la WiFi

Executați următoarele comenzi pe dispozitiv:

din rețeaua de import WLANwlan = WLAN (mode = WLAN. STA) nets = wlan.scan () pentru net în nets: if net.ssid == 'ESSID': print ('Network found!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), timeout = 5000) în timp ce nu este wlan.isconnected (): machine.idle () print ('conexiunea WLAN a reușit!') pauză

Înlocuiți ESSID cu numele rețelei dvs. WiFi și PASS cu parola acestuia.

Pasul 6: Inițializați comunicarea cu Modbus Slave

Bibliotecile Modbus Master sunt similare pentru ambele dispozitive

Ele variază ca inițializare.

1) Inițializați uModBus pe Moduino ESP32

A executa:

din uModBusTCP importați uModBusTCP ca TCP

2) Inițializați uModBus pe Pycom

A executa:

din uModbus.tcp import TCP

Conexiune deschisă

Apoi deschideți conexiunea cu:

modbus = TCP („IP”, PORT, 60)

Unde:

• IP - adresa IP a computerului dvs. cu simulatorul Modbus Slave
• PORT - portul Modbus Slave
• 60 este un timeout

Dacă apare următoarea eroare în timpul executării comenzilor de citire / scriere: EXEMPLU

a executa:

pentru Moduino ESP32:

modbus.close ()

pentru Moduino Pycom:

modbus._sock.close ()

și apoi recreați conexiunea:

modbus = TCP („IP”, PORT, 60)

Acest lucru este important pentru a închide soclul înainte de a crea din nou conexiunea.

Pasul 7: Citiți și scrieți registre

Modbus acceptă mai multe funcții pentru citirea și scrierea registrelor.

Biblioteca uModBus are o metodă pentru fiecare funcție:

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

În primul rând, să scriem câteva valori.

1) Scrieți bobine (funcții: 5)

Scrieți 1 valoare la 200 de înregistrări de la sclavul 1:

modbus.write_single_coil (1, 200, 0xFF00)

Primul argument este pentru idul sclavului, în cazul nostru 1.

Al doilea este numărul de registru, iar al treilea este o valoare. Pentru 1 trebuie să puneți 0xFF00 aici. Scrieți înregistrarea 0 la 201 de la sclavul 1:

modbus.write_single_coil (1, 201, 0)

Această metodă permite scrierea numai a valorilor booleene: 0 sau 1.

2) Scrieți registre (funcții: 6)

Acum scrieți câteva valori întregi în mai multe registre.

Scrieți valoarea semnată 111 pentru a înregistra 100 de la sclavul 1:

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

Primul argument este ID-ul sclavului, al doilea număr de registru și al treilea este o valoare nouă. Ultimul argument definește dacă valoarea trebuie setată ca număr semnat. Valoarea implicită pentru aceasta este adevărată. Nu este nevoie să o setați.

Scrieți valoarea semnată -457 la 101 înregistrați de la sclavul 1:

modbus.write_single_register (1, 101, -457)

Scrieți nu semnat 50 la 100 înregistrați de la sclavul 3:

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

Această metodă permite scrierea valorilor întregi într-un singur registru.

Registrul unic poate conține valori de 16 biți.

Metoda returnează True este valoarea de intrare valabilă și False dacă nu. Valoarea este scrisă chiar dacă nu este validă (prea mare pentru înregistrare)

3) Citiți bobine / intrări discrete

Acum permiteți citirea valorilor booleene scrise. Pentru a citi registrul cu bobina de citire a funcției 1, executați:

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

Pentru a citi registrul cu funcția 2, citiți intrarea discretă, executați:

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

Unde:

• slave-id - id-ul slave-ului virtual (simulatorul Slave acceptă toate ID-urile valide)
• registru - număr de înregistrare pentru citire
• număr - cantitatea de registre care trebuie citite (puneți suma dorită în ambele locuri)

Aceste metode returnează matrice cu valori booleene. Fiecare valoare corespunde fiecărui registru.

Este necesar fragmentul: [0: count], deoarece această metodă returnează mai multe valori decât count. Returnează întotdeauna cantitatea de valori divizibilă cu 8. Valorile suplimentare sunt false și nu corespund niciunui registru.

Citiți valorile noastre booleene cu ambele metode:

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

Rezultatul va fi astfel: EXEMPLU

Adevărat se referă la 1 valoare, False la 0.

4) Citiți registrele

Acum citiți valori din registre scrise cu 6 funcții.

Pentru a citi registre cu funcția 3 citire registre de păstrare, executați:

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

Pentru a citi registre cu funcția 4 citiți registre de intrare, executați:

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

Unde:

• slave-id - id al sclavului virtual
• registru - număr de înregistrare pentru citire
• număr - cantitatea de registre care trebuie citite
• semnat - indică dacă valorile citite trebuie tratate sau nu ca numere semnate. Stare implicită: Adevărat

Valoarea returnată este un tuplu cu cantitatea dorită de registre.

Citiți registrele setate la punctul anterior:

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)

Rezultatele ar trebui să arate ca în această captură de ecran: EXEMPLU

În următoarea lecție veți învăța cum să creați Modbus RTU Master pe dispozitivul cu ESP32.