ESP32 Modbus Master TCP: 7 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa klase na ito, ipaprogram mo ang processor ng ESP32 upang maging Modbus TCP Master.

Gumagamit kami ng dalawang aparato, na naglalaman ng processor na ito: Moduino ESP32 at Pycom. Ang parehong mga aparato ay tumatakbo sa kapaligiran ng MicroPytthon. Ang aming Modbus Slave ay magiging PC computer na may Modbus simulator software na tumatakbo dito.

Kakailanganin mong:

• Moduino ESP32 o Moduino Pycom aparato (suriin ang website na ito upang malaman ang higit pa tungkol sa Moduino ESP32 aparato at ito upang suriin ang aparato ng Pycom)
• PC na may operating system ng Linux
• RS-232 / RS-485 port sa iyong computer o USB sa RS-232 / RS-485 converter

Hakbang 1: I-download at Simulan ang Modbus TCP Slave Simulator

I-download ang Modbus Slave simulator mula sa https://www.modbusdriver.com/diagslave.html. Pagkatapos buksan ang na-download na archive at i-unpack ang bersyon para sa operating system ng Linux.

Patakbuhin ang programa mula sa console na may -p argument:

./diagslave -p

ay isang port kung saan gagana ang server ng Modbus Slave. Para sa Modbus protocol ito ay sa pamamagitan ng default 502, ngunit maaari kang gumamit ng isa pa.

Sa mga pantalan sa Linux sa ibaba 1024 ay hindi maaaring gamitin ng mga programang pinapatakbo mula sa regular na gumagamit (hindi mga pribilehiyo sa ugat).

Tandaan kung anong port ang iyong ginagamit. Ang halagang ito ay kakailanganin sa paglaon.

Hakbang 2: Ihanda ang Iyong Computer upang Kumonekta sa Device

Kakailanganin mo ang ilang mga programa upang makakonekta sa aparato at magpadala ng mga file dito.

I-install ang paligid ng Python at pip (kung wala ka nito):

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

I-install ang picocom:

apt-get install picocom

Ang program na ito ay kinakailangan upang kumonekta sa aparato at magpatupad ng mga utos dito. I-install ang mpfshell:

pip install mpfshell

Pinapayagan ka ng program na ito na magpadala ng mga file sa aparato.

Maaari mo ring mai-install ang mga mapagkukunan ng form na ito. Sumangguni sa pahinang ito:

Hakbang 3: Ihanda ang Device at Ikonekta Ito

Upang ikonekta ang aparato ng Moduino o Pycom sa PC kailangan mo ng RS-232 / RS-485 port o converter. Suriin ang bersyon ng iyong aparato (aling uri ng port ang ginagamit nito) at hanapin ang naaangkop na port o converter.

1. Ikonekta ang aparato sa PC
2. Pagkatapos ay ikonekta ang suplay ng kuryente dito

Ikonekta ang aparato sa PC at pagkatapos ay ikonekta ang suplay ng kuryente dito. Maaari mo ring ikonekta ang ethernet cable sa Moduino ESP32 (kung mayroon itong port).

Ang koneksyon ay dapat na tulad ng sa mga larawan sa itaas

Maghanap ng landas para sa port, na ginagamit para sa koneksyon ng aparato. Maaari itong maging halimbawa: / dev / ttyS1, / dev / ttyUSB0.

Para sa mga converter ng usb, maglalaman ang path ng USB salita.

Maaari kang kumonekta sa aparato gamit ang picocom program:

picocom / dev / ttyUSB0 -b 115200

Ang prompt ng utos ng aparato ay katulad ng isa sa mga imaheng ito sa ibaba.

Moduino ESP32: Tingnan dito

Moduino Pycom: Tingnan dito

Hakbang 4: Mag-upload ng Modbus Master Library

github.com/pycom/pycom-modbus/ Upang makipag-usap sa Modbus Slave kailangan mo ng naaangkop na library. Ang mga aklatan para sa Pycom ay hindi tugma sa Moduino. Suriin ang mga tagubilin na sumusunod sa iyong aparato.

Isara ang picocom bago magpadala ng mga file: pindutin ang Ctrl + A at pagkatapos ang Ctrl + X keys.

uModBus library para sa Moduino ESP32 mga base sa pycom-modbus library para sa Moduino Pycom. Nabago ito upang gumana sa regular na aparato ng ESP32. Mayroon din itong karagdagang mga malapit () na pamamaraan para sa mga klase ng konektor.

1) Moduino ESP32

Mag-download ng library mula sa https://github.com/techbase123/micropython-modbus. I-unpack ang archive at ipadala ang lahat ng 4 na mga file sa Moduino aparato.

Gumamit ng mpfshell upang mai-upload ang mga ito. Patakbuhin ang program na ito sa direktoryo kasama ang mga file na iyon.

Kumonekta sa aparato sa pamamagitan ng pagpapatupad: ITO

Ang ttyUSB0 ay isang pangalan ng serial port kung saan nakakonekta ang aparato.

Baguhin ang direktoryo sa / flash / lib gamit ang utos:

cd / flash / lib

Ilagay ang lahat ng mga file na may mga utos:

ilagay ang uModBusConst.py

ilagay uModBusFunction.py ilagay uModBusTCP.py ilagay uModBusSerial.py

HALIMBAWA

Pagkatapos ay lumabas ng console na may exit command at i-restart ang aparato gamit ang pindutang I-reset.

2) Moduino Pycom

Mag-download ng library mula sa https://github.com/pycom/pycom-modbus/. I-unpack ang archive at ipadala ang nilalaman ng direktoryo ng uModbus sa aparato. Gumamit ng mpfshell upang mai-upload ang mga ito. Patakbuhin ang program na ito sa direktoryo kasama ang mga file na iyon.

Kumonekta sa aparato sa pamamagitan ng pagpapatupad:

buksan ang ttyUSB0

Ang ttyUSB0 ay isang pangalan ng serial port kung saan nakakonekta ang aparato.

Baguhin ang direktoryo sa / flash / lib, lumikha ng direktoryo ng uModbus at ipasok ito gamit ang mga utos:

cd / flash / libmd uModbus cd uModbus

Ilagay ang lahat ng mga file na may mga utos:

ilagay ang Const.py

ilagay ang mga function.py ilagay ang tcp.py ilagay ang serial.py

Pagkatapos ay lumabas ng console na may exit command at i-restart ang aparato gamit ang pindutang I-reset.

HALIMBAWA

Hakbang 5: Kumonekta sa Network

Ang mga utos na magtaguyod ng koneksyon ay magkakaiba sa pagitan ng Moduino at Pycom.

Kumonekta sa aparato gamit ang picocom upang magpatupad ng naaangkop na mga utos. Maaari mong ikonekta ang aparato ng Moduino sa network sa pamamagitan ng wire o wireless. Ang mga sumusunod na halimbawa ay ipinapalagay na ang iyong network ay may gumaganang DHCP server.

Sa ibang kaso, ang aparato ay hindi makakakuha ng IP address. Ang suporta sa WiFi ay magagamit sa bawat Moduino. Ang Ethernet port ay isang pagpipilian at hindi lahat ng mga aparato ay mayroon nito.

1) Moduino ESP32

Kumokonekta sa WiFi

Ipatupad ang mga sumusunod na utos sa aparato:

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

Palitan ang ESSID ng pangalan ng iyong WiFi network, at PASS sa password nito.

Pagkatapos ng ilang oras pagkatapos ng pagpapatupad ng pagsisimula () dapat kang makakuha ng isang IP address na naitalaga sa iyong aparato.

Kumokonekta sa Ethernet network

Ikonekta ang aparato sa wired network gamit ang ethernet cable.

Pagkatapos ay magpatupad ng mga sumusunod na utos:

mula sa netETH import netETHeth = netETH () et.start ()

Pagkatapos ng ilang oras pagkatapos ng pagpapatupad ng pagsisimula () dapat kang makakuha ng IP address na naitalaga sa iyong aparato.

2) Moduino Pycom

Kumonekta sa WiFi

Ipatupad ang mga sumusunod na utos sa aparato:

mula sa network import WLANwlan = WLAN (mode = WLAN. STA) nets = wlan.scan () para sa net sa mga lambat: kung net.ssid == 'ESSID': print ('Nahanap ang network!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), timeout = 5000) habang hindi wlan.isconnected (): machine.idle () print ('Matagumpay ang koneksyon sa WLAN!') break

Palitan ang ESSID ng pangalan ng iyong WiFi network, at PASS sa password nito.

Hakbang 6: Pasimulan ang Komunikasyon Sa Modbus Slave

Ang mga library ng Modbus Master ay pareho para sa parehong mga aparato

Nag-iiba sila sa pagsisimula.

1) Simulan ang uModBus sa Moduino ESP32

Isagawa:

mula sa uModBusTCP i-import ang uModBusTCP bilang TCP

2) Simulan ang uModBus sa Pycom

Isagawa:

mula sa uModbus.tcp import TCP

Buksan ang koneksyon

Pagkatapos buksan ang koneksyon sa:

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

kung saan:

• IP - ip address ng iyong PC gamit ang Modbus Slave simulator
• PORT - daungan ng Modbus Slave
• 60 ay isang timeout

Kung ang sumusunod na error ay nangyayari habang isinasagawa ang mga utos sa pagbasa / pagsulat: HALIMBAWA

magpatupad:

para sa Moduino ESP32:

modbus.close ()

para sa Moduino Pycom:

modbus._sock.close ()

at pagkatapos ay muling likhain ang koneksyon:

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

Ito ay mahalaga upang isara ang socket bago muling likhain ang koneksyon. Ang aparato ay may hadlang na halaga ng magagamit na koneksyon ng socket.

Hakbang 7: Basahin at Isulat ang Mga Rehistro

Sinusuportahan ng Modbus ang maraming mga pag-andar upang mabasa at magsulat ng mga rehistro.

Ang uModBus library ay may pamamaraan para sa bawat pagpapaandar:

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

Una, hinahayaan na magsulat ng ilang mga halaga.

1) Sumulat ng mga coil (func: 5)

Sumulat ng 1 halaga hanggang 200 magparehistro mula sa alipin 1:

modbus.write_single_coil (1, 200, 0xFF00)

Ang unang argumento ay para sa slave id, sa aming kaso 1.

Pangalawa ang rehistro numero at ang uhaw ay isang halaga. Para sa 1 kailangan mong ilagay ang 0xFF00 dito. Sumulat ng 0 hanggang 201 sa pagrehistro mula sa alipin 1:

modbus.write_single_coil (1, 201, 0)

Pinapayagan ng pamamaraang ito ang pagbuo lamang ng mga halagang boolean: 0 o 1.

2) Sumulat ng mga rehistro (func: 6)

Sumulat ngayon ng ilang mga halaga ng integer sa maraming mga pagrehistro.

Sumulat ng nilagdaang 111 na halaga upang magparehistro ng 100 mula sa alipin 1:

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

Ang unang argumento ay ang id ng alipin, ang pangalawang numero ng rehistro at ang pangatlo ay bagong halaga. Ang huling argument ay tumutukoy kung ang halaga ay dapat itakda bilang naka-sign na numero. Ang default na halaga para dito ay Totoo. Hindi mo kailangang itakda ito.

Sumulat ng nilagdaan -457 na halaga sa 101 magparehistro mula sa alipin 1:

modbus.write_single_register (1, 101, -457)

Sumulat na hindi nilagdaan na 50 na halaga sa 100 magparehistro mula sa alipin 3:

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

Pinapayagan ng pamamaraang ito ang pag-writting ng mga halaga ng integer sa solong pagrehistro.

Ang solong rehistro ay maaaring maglaman ng 16 na halaga.

Nagbabalik ang pamamaraan ng True ay wasto ang halaga ng pag-input at Mali kung hindi. Ang halaga ay nakasulat kahit na hindi wasto (masyadong malaki para sa pagrehistro)

3) Basahin ang mga coil / discrete input

Hinahayaan ngayong basahin ang mga nakasulat na halagang boolean. Upang mabasa ang rehistro na may function na 1 read coil, ipatupad:

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

Upang basahin ang pagrehistro gamit ang pagpapaandar 2 na basahin ang discrete input, ipatupad:

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

kung saan:

• slave-id - id ng virtual na alipin (Tumatanggap ang Slave simulator ng lahat ng wastong id)
• magparehistro - numero ng rehistro para sa pagbabasa
• bilang - dami ng mga rehistro na babasahin (ilagay ang ninanais na halaga sa parehong lugar)

Ang mga pamamaraang ito ay nagbabalik ng array na may mga halagang boolean. Ang bawat halaga ay tumutugma sa bawat rehistro.

Ang fragment: [0: count] ay kinakailangan, dahil ang pamamaraang ito ay nagbabalik ng higit pang mga halaga, kaysa sa bilang. Nagbabalik ito palaging halaga ng mga halagang maaaring mahati ng 8. Ang mga karagdagang halaga ay Mali at hindi tumutugma sa anumang rehistro.

Basahin ang aming mga halagang boolean gamit ang parehong pamamaraan:

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

Ang resulta ay magiging katulad nito: HALIMBAWA

Ang totoo ay tumutukoy sa 1 halaga, Mali sa 0.

4) Basahin ang mga rehistro

Ngayon basahin ang mga halaga mula sa mga rehistro na nakasulat na may 6 na pagpapaandar.

Upang basahin ang mga rehistro na may function na 3 basahin ang mga rehistro ng hawak, magpatupad ng:

modbus.read_holding_registers (slaveId, rehistro, bilang, nilagdaan = Totoo)

Upang mabasa ang mga rehistro na may function na 4 na basahin ang mga rehistro ng input, ipatupad:

modbus.read_input_registers (slaveId, rehistro, bilang, nilagdaan = Totoo)

kung saan:

• slave-id - id ng virtual na alipin
• magparehistro - numero ng rehistro para sa pagbabasa
• bilangin - ang bilang ng mga rehistro na babasahin
• nilagdaan - ipinapahiwatig kung ang mga halagang binasa ay dapat tratuhin bilang naka-sign na numero o hindi. Default na estado: Tama

Ang halaga ng pagbabalik ay isang tuple na may nais na dami ng mga rehistro.

Basahin ang mga rehistro na itinakda sa nakaraang punto:

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

Ang mga resulta ay dapat magmukhang sa screenshot na ito: HALIMBAWA

Sa susunod na aralin matututunan mo kung paano lumikha ng Modbus RTU Master sa aparatong pinagana ng ESP32.