ESP32 Modbus Master TCP: 7 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

In deze les programmeer je de ESP32-processor als Modbus TCP Master.

We zullen twee apparaten gebruiken die deze processor bevatten: Moduino ESP32 en Pycom. Beide apparaten draaien in een MicroPytthon-omgeving. Onze Modbus Slave zal een pc-computer zijn waarop Modbus-simulatorsoftware draait.

Je zal nodig hebben:

• Moduino ESP32- of Moduino Pycom-apparaat (kijk op deze website voor meer informatie over het Moduino ESP32-apparaat en dit om het Pycom-apparaat te controleren)
• PC met Linux-besturingssysteem
• RS-232/RS-485-poort in uw computer of USB naar RS-232/RS-485-converter

Stap 1: Download en start Modbus TCP Slave Simulator

Download de Modbus Slave-simulator van https://www.modbusdriver.com/diagslave.html. Open vervolgens het gedownloade archief en pak de versie uit voor het Linux-besturingssysteem.

Voer het programma uit vanaf de console met het argument -p:

./diagslave -p

is een poort waar de Modbus Slave-server zal werken. Voor het Modbus-protocol is dit standaard 502, maar u kunt een andere gebruiken.

In Linux kunnen poorten lager dan 1024 niet worden gebruikt door programma's die door een gewone gebruiker worden uitgevoerd (geen root-privileges).

Onthoud welke poort u gebruikt. Deze waarde is later nodig.

Stap 2: Bereid uw computer voor om verbinding te maken met het apparaat

U hebt enkele programma's nodig om verbinding te maken met het apparaat en er bestanden naar te verzenden.

Installeer de Python-omgeving en pip (als je die niet hebt):

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

Installeer picocom:

apt-get install picocom

Dit programma is nodig om verbinding te maken met het apparaat en er opdrachten op uit te voeren. Installeer mpfshell:

pip installeer mpfshell

Met dit programma kunt u bestanden naar het apparaat verzenden.

Je kunt het ook vanuit bronnen installeren. Raadpleeg deze pagina:

Stap 3: Bereid het apparaat voor en maak er verbinding mee

Om het Moduino- of Pycom-apparaat op de pc aan te sluiten, hebt u een RS-232/RS-485-poort of converter nodig. Controleer de versie van uw apparaat (welk poorttype het gebruikt) en zoek de juiste poort of converter.

1. Apparaat aansluiten op pc
2. Sluit er vervolgens de voeding op aan

Sluit het apparaat aan op de pc en sluit er vervolgens de voeding op aan. U kunt ook een ethernetkabel aansluiten op Moduino ESP32 (als deze die poort heeft).

De verbinding moet zijn zoals op de bovenstaande foto's

Vind pad voor poort, die wordt gebruikt voor apparaatverbinding. Dit kan bijvoorbeeld zijn: /dev/ttyS1, /dev/ttyUSB0.

Voor usb-converters bevat het pad een USB-woord.

U kunt verbinding maken met het apparaat met het picocom-programma:

picocom /dev/ttyUSB0 -b 115200

De opdrachtprompt van het apparaat lijkt op een van de onderstaande afbeeldingen.

Moduino ESP32: Zie hier

Moduino Pycom: Zie hier

Stap 4: Upload Modbus Master-bibliotheek

github.com/pycom/pycom-modbus/Om te communiceren met Modbus Slave heb je de juiste bibliotheek nodig. Bibliotheken voor Pycom zijn niet compatibel met Moduino. Controleer de instructies die overeenkomen met uw apparaat.

Sluit picocom af voordat u bestanden verzendt: druk op Ctrl+A en vervolgens op Ctrl+X.

uModBus-bibliotheek voor Moduino ESP32 is gebaseerd op pycom-modbus-bibliotheek voor Moduino Pycom. Het is aangepast om te werken op een normaal ESP32-apparaat. Het heeft ook aanvullende close()-methoden voor connectorklassen.

1) Moduino ESP32

Download bibliotheek van https://github.com/techbase123/micropython-modbus. Pak het archief uit en stuur alle 4 bestanden naar het Moduino-apparaat.

Gebruik mpfshell om ze te uploaden. Voer dit programma uit in de map met die bestanden.

Maak verbinding met het apparaat door het volgende uit te voeren: DIT

ttyUSB0 is een naam van de seriële poort waarop het apparaat is aangesloten.

Verander de map naar /flash/lib met het commando:

cd /flash/lib

Zet alle bestanden met commando's:

zet uModBusConst.py

zet uModBusFunctions.py zet uModBusTCP.py zet uModBusSerial.py

VOORBEELD

Sluit vervolgens de console af met het exit-commando en start het apparaat opnieuw op met de Reset-knop.

2) Moduino Pycom

Download bibliotheek van https://github.com/pycom/pycom-modbus/. Pak het archief uit en stuur de inhoud van de uModbus-map naar het apparaat. Gebruik mpfshell om ze te uploaden. Voer dit programma uit in de map met die bestanden.

Maak verbinding met het apparaat door het volgende uit te voeren:

open ttyUSB0

ttyUSB0 is een naam van de seriële poort waarop het apparaat is aangesloten.

Wijzig de map naar /flash/lib, maak de uModbus-map aan en voer deze in met opdrachten:

cd /flash/libmd uModbus cd uModbus

Zet alle bestanden met commando's:

zet const.py

put functions.py put tcp.py put serial.py

Sluit vervolgens de console af met het exit-commando en start het apparaat opnieuw op met de Reset-knop.

VOORBEELD

Stap 5: Maak verbinding met het netwerk

Commando's om verbinding te maken verschillen tussen Moduino en Pycom.

Maak verbinding met het apparaat met picocom om de juiste opdrachten uit te voeren. U kunt het Moduino-apparaat via draad of draadloos op het netwerk aansluiten. De volgende voorbeelden gaan ervan uit dat uw netwerk een werkende DHCP-server heeft.

In andere gevallen krijgt het apparaat geen IP-adres. WiFi-ondersteuning is beschikbaar in elke Moduino. Ethernet-poort is een optie en niet alle apparaten hebben het.

1) Moduino ESP32

Verbinding maken met wifi

Voer de volgende opdrachten uit op het apparaat:

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

Vervang ESSID door de naam van uw WiFi-netwerk en PASS door het wachtwoord ervan.

Na enige tijd na het uitvoeren van start() zou u een IP-adres moeten krijgen dat aan uw apparaat is toegewezen.

Verbinding maken met Ethernet-netwerk

Verbind het apparaat met een bekabeld netwerk met een ethernetkabel.

Voer vervolgens de volgende opdrachten uit:

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

Na enige tijd na het uitvoeren van start() zou u het IP-adres moeten krijgen dat aan uw apparaat is toegewezen.

2) Moduino Pycom

Maak verbinding met wifi

Voer de volgende opdrachten uit op het apparaat:

van netwerkimport WLANwlan = WLAN(mode=WLAN. STA) nets = wlan.scan() voor net in nets:if net.ssid == 'ESSID': print('Netwerk gevonden!') wlan.connect(net.ssid, auth=(net.sec, 'PASS'), timeout=5000) terwijl niet wlan.isconnected(): machine.idle() print('WLAN-verbinding geslaagd!') break

Vervang ESSID door de naam van uw WiFi-netwerk en PASS door het wachtwoord ervan.

Stap 6: Communicatie met Modbus-slave initialiseren

Modbus Master-bibliotheken zijn vergelijkbaar voor beide apparaten

Ze variëren in initialisatie.

1) Initialiseer uModBus op Moduino ESP32

uitvoeren:

van uModBusTCP importeer uModBusTCP als TCP

2) Initialiseer uModBus op Pycom

uitvoeren:

van uModbus.tcp import TCP

Verbinding openen

Open dan verbinding met:

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

waar:

• IP - ip-adres van uw pc met Modbus Slave-simulator
• POORT - poort van Modbus Slave
• 60 is een time-out

Als de volgende fout optreedt tijdens het uitvoeren van lees-/schrijfopdrachten: VOORBEELD

uitvoeren:

voor Moduino ESP32:

modbus.close()

voor Moduino Pycom:

modbus._sock.close()

en maak vervolgens opnieuw verbinding:

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

Dit is belangrijk om de socket te sluiten voordat de verbinding opnieuw wordt gemaakt. Het apparaat heeft een beperkte hoeveelheid beschikbare socketverbinding.

Stap 7: Registers lezen en schrijven

Modbus ondersteunt verschillende functies om registers te lezen en te schrijven.

uModBus-bibliotheek heeft een methode voor elke functie:

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

Laten we eerst enkele waarden schrijven.

1) Schrijfspoelen (func: 5)

Schrijf 1 waarde naar 200 register van slave 1:

modbus.write_single_coil(1, 200, 0xFF00)

Het eerste argument is voor slave-id, in ons geval 1.

Ten tweede is het registernummer en thirs is een waarde. Voor 1 moet je hier 0xFF00 plaatsen. Schrijf 0 tot 201 register van slave 1:

modbus.write_single_coil(1, 201, 0)

Met deze methode kunnen alleen booleaanse waarden worden geschreven: 0 of 1.

2) Schrijf registers (func: 6)

Schrijf nu enkele gehele waarden naar verschillende registers.

Schrijf ondertekende 111-waarde naar register 100 van slaaf 1:

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

Het eerste argument is het slave-ID, het tweede registernummer en het derde is de nieuwe waarde. Het laatste argument bepaalt of de waarde moet worden ingesteld als een ondertekend nummer. De standaardwaarde ervoor is True. Je hoeft het niet in te stellen.

Schrijf ondertekende -457 waarde naar 101 register van slave 1:

modbus.write_single_register(1, 101, -457)

Schrijf niet ondertekende 50 waarde naar 100 register van slave 3:

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

Met deze methode kunnen gehele getallen naar een enkel register worden geschreven.

Een enkel register kan 16 bit-waarden bevatten.

Methode retourneert True als de invoerwaarde geldig is en False als dat niet het geval is. Waarde wordt geschreven, zelfs als deze ongeldig is (te groot voor register)

3) Lees spoelen/discrete ingangen:

Laten we nu de geschreven booleaanse waarden lezen. Om register met functie 1 leesspoel uit te lezen, voert u uit:

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

Om register te lezen met functie 2 lees discrete input, voer uit:

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

waar:

• slave-id - id van virtuele slaaf (Slave-simulator accepteert alle geldige id's)
• register - registernummer voor lezen
• count - aantal te lezen registers (zet het gewenste aantal op beide plaatsen)

Deze methoden retourneren array met booleaanse waarden. Elke waarde komt overeen met elk register.

Het fragment: [0:count] is nodig, omdat deze methode meer waarden retourneert dan count. Het retourneert altijd het aantal waarden dat deelbaar is door 8. Extra waarden zijn False en komen niet overeen met een register.

Lees onze booleaanse waarden met beide methoden:

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

Het resultaat zal als volgt zijn: VOORBEELD

True verwijst naar 1 waarde, False naar 0.

4) Lees registers

Lees nu waarden uit registers geschreven met 6 functie.

Om registers te lezen met functie 3 lees holding registers, voer je uit:

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

Om registers te lezen met functie 4 lees ingangsregisters, voer uit:

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

waar:

• slave-id - id van virtuele slaaf
• register - registernummer voor lezen
• count - aantal te lezen registers
• ondertekend - geeft aan of gelezen waarden moeten worden behandeld als ondertekende nummers of niet. Standaardstatus: True

Retourwaarde is een tuple met het gewenste aantal registers.

Lees registers ingesteld in vorig punt:

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)

De resultaten zouden eruit moeten zien als in deze schermafbeelding: VOORBEELD

In de volgende les leert u hoe u Modbus RTU Master kunt maken op een ESP32-apparaat.