ESP32 Modbus Master TCP: 7 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

ამ კლასში თქვენ დააპროგრამებთ ESP32 პროცესორს Modbus TCP Master.

ჩვენ გამოვიყენებთ ორ მოწყობილობას, რომელიც შეიცავს ამ პროცესორს: Moduino ESP32 და Pycom. ორივე მოწყობილობა მუშაობს MicroPytthon გარემოში. ჩვენი Modbus Slave იქნება კომპიუტერული კომპიუტერი, რომელზეც Modbus სიმულატორის პროგრამული უზრუნველყოფა მუშაობს.

თქვენ დაგჭირდებათ:

• Moduino ESP32 ან Moduino Pycom მოწყობილობა (შეამოწმეთ ეს ვებ გვერდი, რომ გაიგოთ მეტი Moduino ESP32 მოწყობილობის შესახებ და ეს Pycom მოწყობილობის შესამოწმებლად)
• კომპიუტერი Linux ოპერაციული სისტემით
• RS-232/RS-485 პორტი თქვენს კომპიუტერში ან USB– ში RS-232/RS-485 გადამყვანი

ნაბიჯი 1: ჩამოტვირთეთ და დაიწყეთ Modbus TCP Slave Simulator

ჩამოტვირთეთ Modbus Slave სიმულატორი https://www.modbusdriver.com/diagslave.html. შემდეგ გახსენით გადმოწერილი არქივი და ამოიღეთ ვერსია Linux ოპერაციული სისტემისთვის.

გაუშვით პროგრამა კონსოლიდან -p არგუმენტით:

./დიაგსლავ -გ

არის პორტი, სადაც Modbus Slave სერვერი იმუშავებს. Modbus პროტოკოლისთვის ის არის სტანდარტულად 502, მაგრამ შეგიძლიათ გამოიყენოთ სხვა.

Linux– ის 1024 – ის ქვემოთ მდებარე პორტებში არ შეიძლება გამოყენებულ იქნეს რეგულარული მომხმარებლის პროგრამები (არა root პრივილეგიები).

დაიმახსოვრეთ რა პორტს იყენებთ. ეს მნიშვნელობა მოგვიანებით იქნება საჭირო.

ნაბიჯი 2: მოამზადეთ თქვენი კომპიუტერი მოწყობილობასთან დასაკავშირებლად

თქვენ დაგჭირდებათ რამდენიმე პროგრამა მოწყობილობასთან დასაკავშირებლად და ფაილების გასაგზავნად.

დააინსტალირეთ პითონის გარემო და პიპი (თუ არ გაქვთ):

apt-get დააინსტალირეთ python3

apt-get დააინსტალირეთ python3-dev curl "https://bootstrap.pypa.io/get-pip.py" -o "get-pip.py" python3 get-pip.py

დააინსტალირეთ პიკოკომი:

apt-get დააინსტალირეთ პიკოკომი

ეს პროგრამა საჭიროა მოწყობილობასთან დასაკავშირებლად და მასზე ბრძანებების შესასრულებლად. დააინსტალირეთ mpfshell:

pip დააინსტალირეთ mpfshell

ეს პროგრამა საშუალებას გაძლევთ გაგზავნოთ ფაილები მოწყობილობაზე.

თქვენ ასევე შეგიძლიათ დააინსტალიროთ იგი წყაროებიდან. იხილეთ ეს გვერდი:

ნაბიჯი 3: მოამზადეთ მოწყობილობა და დაუკავშირდით მას

Moduino ან Pycom მოწყობილობა კომპიუტერთან დასაკავშირებლად გჭირდებათ RS-232/RS-485 პორტი ან გადამყვანი. შეამოწმეთ თქვენი მოწყობილობის ვერსია (რომელი პორტის ტიპს იყენებს) და იპოვეთ შესაბამისი პორტი ან გადამყვანი.

1. შეაერთეთ მოწყობილობა კომპიუტერთან
2. შემდეგ დაუკავშირეთ მას კვების ბლოკი

შეაერთეთ მოწყობილობა კომპიუტერთან და შემდეგ დაუკავშირეთ მას კვების ბლოკი. თქვენ ასევე შეგიძლიათ დააკავშიროთ Ethernet კაბელი Moduino ESP32– ს (თუ მას აქვს ეს პორტი).

კავშირი უნდა იყოს როგორც ზემოთ მოცემულ ფოტოებში

იპოვეთ პორტის გზა, რომელიც გამოიყენება მოწყობილობის დასაკავშირებლად. ეს შეიძლება იყოს მაგალითად: /dev /ttyS1, /dev /ttyUSB0.

USB კონვერტორებისთვის, გზა შეიცავს USB სიტყვას.

შეგიძლიათ დაუკავშირდეთ მოწყობილობას picocom პროგრამით:

picocom /dev /ttyUSB0 -b 115200

მოწყობილობის ბრძანების სტრიქონი ჰგავს ქვემოთ მოცემულ სურათებს.

Moduino ESP32: იხილეთ აქ

Moduino Pycom: იხილეთ აქ

ნაბიჯი 4: ატვირთეთ Modbus სამაგისტრო ბიბლიოთეკა

github.com/pycom/pycom-modbus/ Modbus Slave– თან დასაკავშირებლად გჭირდებათ შესაბამისი ბიბლიოთეკა. Pycom– ის ბიბლიოთეკები არ არის თავსებადი Moduino– სთან. შეამოწმეთ ინსტრუქციები, რომლებიც შეესაბამება თქვენს მოწყობილობას.

დახურეთ პიკოკომი ფაილების გაგზავნამდე: დააჭირეთ Ctrl+A და შემდეგ Ctrl+X კლავიშებს.

uModBus ბიბლიოთეკა Moduino– სთვის ESP32 ემყარება pycom – modbus ბიბლიოთეკას Moduino Pycom– ისთვის. ის შეცვლილია ჩვეულებრივ ESP32 მოწყობილობაზე მუშაობისთვის. მას ასევე აქვს დამატებითი დახურვის () მეთოდები შემაერთებელი კლასებისთვის.

1) მოდუინო ESP32

ჩამოტვირთეთ ბიბლიოთეკა https://github.com/techbase123/micropython-modbus– დან. გახსენით არქივი და გაგზავნეთ ოთხივე ფაილი Moduino მოწყობილობაში.

გამოიყენეთ mpfshell მათ ასატვირთად. გაუშვით ეს პროგრამა დირექტორიაში ამ ფაილებით.

დაუკავშირდით მოწყობილობას: THIS

ttyUSB0 არის სერიული პორტის სახელი, სადაც მოწყობილობა არის დაკავშირებული.

შეცვალეთ დირექტორია /flash /lib ბრძანებით:

cd /flash /lib

განათავსეთ ყველა ფაილი ბრძანებით:

განათავსეთ uModBusConst.py

დააყენე uModBusFunctions.py დააყენე uModBusTCP.py დააყენე uModBusSerial.py

მაგალითი

შემდეგ გამოდით კონსოლიდან გამოსვლის ბრძანებით და გადატვირთეთ მოწყობილობა გადატვირთვის ღილაკით.

2) მოდუინო პიკომი

ჩამოტვირთეთ ბიბლიოთეკა https://github.com/pycom/pycom-modbus/. გახსენით არქივი და გაგზავნეთ uModbus დირექტორიის შინაარსი მოწყობილობაზე. გამოიყენეთ mpfshell მათი ასატვირთად. გაუშვით ეს პროგრამა დირექტორიაში ამ ფაილებით.

დაუკავშირდით მოწყობილობას შესრულებით:

გახსენით ttyUSB0

ttyUSB0 არის სერიული პორტის სახელი, სადაც მოწყობილობა არის დაკავშირებული.

შეცვალეთ დირექტორია /flash /lib, შექმენით uModbus დირექტორია და შეიყვანეთ იგი ბრძანებებით:

cd /flash /libmd uModbus cd uModbus

განათავსეთ ყველა ფაილი ბრძანებით:

დააყენა const.py

დააყენე ფუნქციები. py დააყენე tcp.py დააყენე serial.py

შემდეგ გამოდით კონსოლიდან გამოსვლის ბრძანებით და გადატვირთეთ მოწყობილობა გადატვირთვის ღილაკით.

მაგალითი

ნაბიჯი 5: დაუკავშირდით ქსელს

ბრძანებები კავშირის დასამყარებლად განსხვავდება Moduino– სა და Pycom– ს შორის.

დაუკავშირდით მოწყობილობას პიკოკომით შესაბამისი ბრძანებების შესასრულებლად. შეგიძლიათ Moduino მოწყობილობა დაუკავშიროთ ქსელს მავთულის ან უკაბელო საშუალებით. შემდეგი მაგალითები ვარაუდობს, რომ თქვენს ქსელს აქვს DHCP სერვერი.

სხვა შემთხვევაში, მოწყობილობა ვერ მიიღებს IP მისამართს. Wi -Fi მხარდაჭერა ხელმისაწვდომია ყველა მოდუინოში. Ethernet პორტი არის ვარიანტი და ყველა მოწყობილობას არ აქვს.

1) მოდუინო ESP32

დაკავშირება WiFi- სთან

შეასრულეთ შემდეგი ბრძანებები მოწყობილობაზე:

netWiFi იმპორტიდან netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

შეცვალეთ ESSID თქვენი WiFi ქსელის სახელით და PASS მისი პაროლით.

დაწყების () დაწყებიდან რამდენიმე ხნის შემდეგ თქვენ უნდა მიიღოთ IP მისამართი, რომელიც მინიჭებული იყო თქვენს მოწყობილობაზე.

დაკავშირება Ethernet ქსელთან

შეაერთეთ მოწყობილობა სადენიანი ქსელით Ethernet კაბელით.

შემდეგ შეასრულეთ შემდეგი ბრძანებები:

netETH– დან იმპორტი netETHeth = netETH () eth.start ()

დაწყების () დაწყებიდან რამდენიმე ხნის შემდეგ თქვენ უნდა მიიღოთ IP მისამართი, რომელიც მინიჭებული იყო თქვენს მოწყობილობაზე.

2) მოდუინო პიკომი

დაუკავშირდით WiFi- ს

შეასრულეთ შემდეგი ბრძანებები მოწყობილობაზე:

ქსელის იმპორტიდან WLANwlan = WLAN (რეჟიმი = WLAN. STA) ბადეები = wlan.scan () ქსელებისთვის ქსელში: if net.ssid == 'ESSID': print ('Network found!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), timeout = 5000) სანამ არ wlan.isconnected (): machine.idle () print ('WLAN კავშირი წარმატებულია!') შესვენება

შეცვალეთ ESSID თქვენი WiFi ქსელის სახელით და PASS მისი პაროლით.

ნაბიჯი 6: დაიწყეთ ურთიერთობა Modbus Slave– თან

Modbus Master ბიბლიოთეკები მსგავსია ორივე მოწყობილობისთვის

ისინი განსხვავდებიან ინიციალიზაციით.

1) uModBus– ის ინიციალიზაცია Moduino ESP32– ზე

შესრულება:

uModBusTCP– დან იმპორტი uModBusTCP როგორც TCP

2) uModBus– ის ინიციალიზაცია Pycom– ზე

შესრულება:

uModbus.tcp იმპორტი TCP

გახსენით კავშირი

შემდეგ გახსენით კავშირი:

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

სად:

• IP - თქვენი კომპიუტერის IP მისამართი Modbus Slave სიმულატორით
• პორტი - მოდბუს მონას პორტი
• 60 არის ტაიმაუტი

თუ შემდეგი შეცდომა წარმოიქმნება წაკითხვის/წერის ბრძანებების შესრულებისას: EXAMPLE

შეასრულე:

Moduino ESP32– ისთვის:

modbus.close ()

Moduino Pycom– ისთვის:

modbus._sock.close ()

და შემდეგ ხელახლა შექმენით კავშირი:

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

ეს მნიშვნელოვანია, რომ დაიხუროს სოკეტი კავშირის ხელახლა შექმნამდე. მოწყობილობას შეზღუდული აქვს არსებული სოკეტის კავშირი.

ნაბიჯი 7: წაიკითხეთ და ჩაწერეთ რეგისტრები

Modbus მხარს უჭერს რამდენიმე ფუნქციას რეგისტრაციის წაკითხვისა და ჩაწერისთვის.

uModBus ბიბლიოთეკას აქვს მეთოდი თითოეული ფუნქციისთვის:

1. წაკითხული_კოლები
2. წაკითხული_დისკრეტული_მონაცემები
3. წაკითხული_ჰოლდინგი_რეგისტრები
4. read_input_registers
5. ჩაწერეთ_ერთჯერადი კოჭა
6. ჩაწერეთ_ერთი_რეგისტრირება

პირველ რიგში, მოდით დავწეროთ რამდენიმე მნიშვნელობა.

1) ჩაწერეთ კოჭები (ფუნქცია: 5)

ჩაწერეთ 1 მნიშვნელობა 200 მონაცემიდან მონა 1 -დან:

modbus.write_single_coil (1, 200, 0xFF00)

პირველი არგუმენტი არის მონა მოწმობა, ჩვენს შემთხვევაში 1.

მეორე არის რეგისტრის ნომერი და thirs არის მნიშვნელობა. 1 -ისთვის აქ უნდა ჩადოთ 0xFF00. ჩაწერეთ 0 დან 201 რეგისტრაცია მონა 1 -დან:

modbus.write_single_coil (1, 201, 0)

ეს მეთოდი იძლევა მხოლოდ ლოგიკური მნიშვნელობების ჩაწერის საშუალებას: 0 ან 1.

2) ჩაწერეთ რეგისტრები (ფუნქცია: 6)

ახლა ჩაწერეთ მთელი რიცხვითი მნიშვნელობა რამდენიმე რეგისტრში.

ჩაწერეთ ხელმოწერილი 111 მნიშვნელობა, რომ დარეგისტრირდეთ 100 მონადან 1:

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

პირველი არგუმენტი არის მონა ID, მეორე რეგისტრის ნომერი და მესამე ახალი მნიშვნელობა. ბოლო არგუმენტი განსაზღვრავს თუ მნიშვნელობა უნდა იყოს მითითებული როგორც ხელმოწერილი ნომერი. ნაგულისხმევი მნიშვნელობა არის True. თქვენ არ გჭირდებათ მისი დაყენება.

ჩაწერეთ ხელმოწერილი -457 მნიშვნელობა 101 მონაში 1 რეგისტრაციისთვის:

modbus.write_single_register (1, 101, -457)

ჩაწერეთ ხელმოუწერელი 50 მნიშვნელობა 100 რეგისტრზე მონა 3 -დან:

modbus.write_single_register (3, 100, 50, ყალბი)

ეს მეთოდი საშუალებას იძლევა მთელი რიცხვითი მნიშვნელობების ჩაწერა ერთ რეგისტრში.

ერთი რეგისტრი შეიძლება შეიცავდეს 16 ბიტიან მნიშვნელობას.

მეთოდი აბრუნებს True არის შეყვანის მნიშვნელობა არის სწორი და False თუ არა. მნიშვნელობა იწერება მაშინაც კი, თუ ის არასწორია (ძალიან დიდია რეგისტრაციისთვის)

3) კოჭების წაკითხვა/დისკრეტული შეყვანა

ახლა მოდით წავიკითხოთ დაწერილი ლოგიკური მნიშვნელობები. რეგისტრაციის წასაკითხად 1 ფუნქციით წაიკითხეთ ხვეული, შეასრულეთ:

modbus.read_coils (slaveId, რეგისტრაცია, დათვლა) [0: count]

რეგისტრაციის წასაკითხად 2 ფუნქციით წაიკითხეთ დისკრეტული შეყვანა, შეასრულეთ:

modbus.read_discrete_inputs (slaveId, რეგისტრაცია, დათვლა) [0: count]

სად:

• slave -id - ვირტუალური მონის id (Slave simulator იღებს ყველა მოქმედ ID- ს)
• რეგისტრაცია - რეგისტრაციის ნომერი კითხვისთვის
• რაოდენობა - წასაკითხი რეგისტრების რაოდენობა (ორივე ადგილას დააყენეთ სასურველი თანხა)

ეს მეთოდები აბრუნებს მასივს ლოგიკური მნიშვნელობებით. თითოეული მნიშვნელობა შეესაბამება თითოეულ რეგისტრს.

ფრაგმენტი: [0: count] საჭიროა, რადგან ეს მეთოდი აბრუნებს უფრო მეტ მნიშვნელობას, ვიდრე რაოდენობა. ის აბრუნებს ყოველთვის მნიშვნელობების რაოდენობას, რომელიც იყოფა 8 -ზე. დამატებითი მნიშვნელობები არის ყალბი და არ შეესაბამება რომელიმე რეგისტრს.

წაიკითხეთ ჩვენი ლოგიკური მნიშვნელობები ორივე მეთოდით:

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

შედეგი იქნება ასეთი: მაგალითი

ჭეშმარიტი ეხება 1 მნიშვნელობას, მცდარია 0 -ს.

4) წაიკითხეთ რეგისტრები

ახლა წაიკითხეთ მნიშვნელობები 6 ფუნქციით დაწერილი რეგისტრებიდან.

3 ფუნქციით რეგისტრების წასაკითხად, წაიკითხეთ ჰოლდინგის რეგისტრები, შეასრულეთ:

modbus.read_holding_registers (slaveId, რეგისტრაცია, დათვლა, ხელმოწერა = True)

4 ფუნქციის მქონე რეგისტრების წასაკითხად შეყვანის რეგისტრების წასაკითხად შეასრულეთ:

modbus.read_input_registers (slaveId, რეგისტრაცია, დათვლა, ხელმოწერა = True)

სად:

• slave -id - ვირტუალური მონის id
• რეგისტრაცია - რეგისტრაციის ნომერი კითხვისთვის
• რაოდენობა - წაკითხული რეგისტრების რაოდენობა
• ხელმოწერილი - მიუთითებს თუ არა წაკითხული მნიშვნელობები განიხილება როგორც ხელმოწერილი რიცხვები თუ არა. ნაგულისხმევი მდგომარეობა: მართალია

დასაბრუნებელი მნიშვნელობა არის სამეული სასურველი რაოდენობის რეგისტრებით.

წაიკითხეთ წინა პუნქტში მითითებული რეგისტრები:

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)

შედეგები უნდა გამოიყურებოდეს ამ ეკრანის სურათზე: EXAMPLE

შემდეგ გაკვეთილზე თქვენ შეისწავლით თუ როგორ უნდა შექმნათ Modbus RTU Master ESP32 ჩართულ მოწყობილობაზე.