ESP32 Modbus Master TCP: 7 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

I den här klassen kommer du att programmera ESP32 -processorn till Modbus TCP Master.

Vi kommer att använda två enheter som innehåller denna processor: Moduino ESP32 och Pycom. Båda enheterna körs i MicroPytthon -miljö. Vår Modbus -slav kommer att vara en PC -dator med Modbus -simulatorprogramvara som körs på den.

Du kommer behöva:

• Moduino ESP32 eller Moduino Pycom -enhet (kolla den här webbplatsen om du vill veta mer om Moduino ESP32 -enheten och detta för att kontrollera Pycom -enheten)
• PC med Linux operativsystem
• RS-232/RS-485-port i din dator eller USB till RS-232/RS-485-omvandlare

Steg 1: Ladda ner och starta Modbus TCP Slave Simulator

Ladda ner Modbus Slave -simulator från https://www.modbusdriver.com/diagslave.html. Öppna sedan det nedladdade arkivet och packa upp versionen för Linux -operativsystemet.

Kör programmet från konsolen med -p argument:

./diagslave -p

är en port där Modbus Slave -servern fungerar. För Modbus -protokollet är det som standard 502, men du kan använda ett annat.

I Linux -portar under 1024 kan inte användas av program som körs från vanlig användare (inte root -privilegier).

Kom ihåg vilken port du använder. Detta värde kommer att behövas senare.

Steg 2: Förbered din dator för att ansluta till enheten

Du behöver några program för att ansluta till enheten och skicka filer till den.

Installera Python -miljö och pip (om du inte har det):

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

Installera picocom:

apt-get installera picocom

Detta program behövs för att ansluta till enheten och utföra kommandon på den. Installera mpfshell:

pip installera mpfshell

Med det här programmet kan du skicka filer till enheten.

Du kan också installera det från källor. Se den här sidan:

Steg 3: Förbered enhet och anslut till den

För att ansluta Moduino eller Pycom enhet till PC behöver du RS-232/RS-485 port eller omvandlare. Kontrollera versionen av din enhet (vilken porttyp den använder) och hitta lämplig port eller omvandlare.

1. Anslut enheten till datorn
2. Anslut sedan strömförsörjningen till den

Anslut enheten till datorn och anslut sedan strömförsörjningen till den. Du kan också ansluta ethernetkabel till Moduino ESP32 (om den har den porten).

Anslutningen ska vara som på bilderna ovan

Hitta sökväg för port, som används för enhetsanslutning. Det kan till exempel vara: /dev /ttyS1, /dev /ttyUSB0.

För usb -omvandlare innehåller sökvägen USB -ord.

Du kan ansluta till enheten med picocom -programmet:

picocom /dev /ttyUSB0 -b 115200

Kommandotolken på enheten liknar en av dessa bilder nedan.

Moduino ESP32: Se här

Moduino Pycom: Se här

Steg 4: Ladda upp Modbus Master Library

github.com/pycom/pycom-modbus/ För att kommunicera med Modbus Slave behöver du lämpligt bibliotek. Bibliotek för Pycom är inte kompatibla med Moduino. Kontrollera instruktioner som följer din enhet.

Stäng picocom innan du skickar filer: tryck på Ctrl+A och sedan på Ctrl+X.

uModBus-bibliotek för Moduino ESP32 baserar sig på pycom-modbus-bibliotek för Moduino Pycom. Det är modifierat för att fungera på vanlig ESP32 -enhet. Det har också ytterligare close () -metoder för anslutningsklasser.

1) Moduino ESP32

Ladda ner biblioteket från https://github.com/techbase123/micropython-modbus. Packa upp arkivet och skicka alla fyra filer till Moduino -enheten.

Använd mpfshell för att ladda upp dem. Kör det här programmet i katalogen med de filerna.

Anslut till enheten genom att köra: DETTA

ttyUSB0 är ett namn på en seriell port där enheten är ansluten.

Ändra katalog till /flash /lib med kommandot:

cd /flash /lib

Sätt alla filer med kommandon:

sätt uModBusConst.py

sätt uModBusFunctions.py sätt uModBusTCP.py sätt uModBusSerial.py

EXEMPEL

Avsluta sedan konsolen med kommandot exit och starta om enheten med knappen Återställ.

2) Moduino Pycom

Ladda ner biblioteket från https://github.com/pycom/pycom-modbus/. Packa upp arkivet och skicka innehållet i uModbus -katalogen till enheten. Använd mpfshell för att ladda upp dem. Kör det här programmet i katalogen med de filerna.

Anslut till enheten genom att köra:

öppna ttyUSB0

ttyUSB0 är ett namn på en seriell port där enheten är ansluten.

Ändra katalog till /flash /lib, skapa uModbus -katalog och ange den med kommandon:

cd /flash /libmd uModbus cd uModbus

Sätt alla filer med kommandon:

sätta const.py

sätta funktioner.py sätta tcp.py sätta serie.py

Avsluta sedan konsolen med kommandot exit och starta om enheten med knappen Återställ.

EXEMPEL

Steg 5: Anslut till nätverket

Kommandon för att upprätta anslutning skiljer sig åt mellan Moduino och Pycom.

Anslut till enheten med picocom för att utföra lämpliga kommandon. Du kan ansluta Moduino -enheten till nätverket via tråd eller trådlöst. Följande exempel förutsätter att ditt nätverk har en fungerande DHCP -server.

I andra fall får enheten ingen IP -adress. Wi -Fi -stöd finns i alla Moduino. Ethernet -port är ett alternativ och inte alla enheter har det.

1) Moduino ESP32

Ansluter till WiFi

Utför följande kommandon på enheten:

från netWiFi import netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

Ersätt ESSID med namnet på ditt WiFi -nätverk och PASS med lösenordet för det.

Efter en tid efter start () bör du få en IP -adress som tilldelades din enhet.

Ansluter till Ethernet -nätverk

Anslut enheten till ett trådbundet nätverk med ethernetkabel.

Utför sedan följande kommandon:

från netETH import netETHeth = netETH () eth.start ()

Efter en tid efter start () bör du få en IP -adress som tilldelades din enhet.

2) Moduino Pycom

Anslut till WiFi

Utför följande kommandon på enheten:

från nätverksimport WLANwlan = WLAN (läge = WLAN. STA) nät = wlan.scan () för nät i nät: om net.ssid == 'ESSID': print ('Nätverk hittat!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), timeout = 5000) medan den inte är wlan.isconnected (): machine.idle () print ('WLAN -anslutningen lyckades!') bryter

Ersätt ESSID med namnet på ditt WiFi -nätverk och PASS med lösenordet för det.

Steg 6: Initiera kommunikation med Modbus Slave

Modbus Master -bibliotek liknar båda enheterna

De varierar i initialisering.

1) Initiera uModBus på Moduino ESP32

Kör:

från uModBusTCP importera uModBusTCP som TCP

2) Initiera uModBus på Pycom

Kör:

från uModbus.tcp importera TCP

Öppen anslutning

Öppna sedan anslutningen med:

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

var:

• IP - ip -adress för din dator med Modbus Slave -simulator
• PORT - hamn på Modbus Slave
• 60 är en timeout

Om följande fel uppstår under läs-/skrivkommandon: EXEMPEL

Kör:

för Moduino ESP32:

modbus.close ()

för Moduino Pycom:

modbus._sock.close ()

och återskapa sedan anslutningen:

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

Detta är viktigt att stänga uttaget innan du återskapar anslutningen. Enheten har begränsat antalet tillgängliga uttag för anslutning.

Steg 7: Läs och skriv register

Modbus stöder flera funktioner för att läsa och skriva register.

uModBus -biblioteket har metod för varje funktion:

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

För det första, låt oss skriva några värden.

1) Skriv spolar (func: 5)

Skriv 1 värde till 200 register från slav 1:

modbus.write_single_coil (1, 200, 0xFF00)

Det första argumentet är för slav -id, i vårt fall 1.

För det andra är registernummer och thirs är ett värde. För 1 måste du sätta 0xFF00 här. Skriv 0 till 201 register från slav 1:

modbus.write_single_coil (1, 201, 0)

Denna metod tillåter bara att skriva booleska värden: 0 eller 1.

2) Skriv register (func: 6)

Skriv nu några heltalsvärden till flera register.

Skriv undertecknat 111 -värde för att registrera 100 från slav 1:

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

Första argumentet är slav -id, andra registernummer och tredje är nytt värde. Senaste argumentet definierar om värdet ska anges som signerat nummer. Standardvärdet för det är True. Du behöver inte ställa in det.

Skriv signerat -457 -värde till 101 register från slav 1:

modbus.write_single_register (1, 101, -457)

Skriv inte signerat 50 värde till 100 register från slav 3:

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

Denna metod gör det möjligt att skriva heltalsvärden till ett enda register.

Enstaka register kan innehålla 16 bitars värden.

Metod returnerar True är inmatningsvärdet giltigt och Falskt om inte. Värdet skrivs även om det är ogiltigt (för stort för register)

3) Läs spolar/diskreta ingångar

Nu kan vi läsa skrivna booleska värden. För att läsa register med funktion 1 läs spole, kör:

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

För att läsa register med funktion 2 läs diskret ingång, kör:

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

var:

• slave -id - id för virtuell slav (Slave simulator accepterar alla giltiga id)
• register - registreringsnummer för läsning
• count - antal register som ska läsas (lägg önskad mängd på båda ställena)

Dessa metoder returnerar array med booleska värden. Varje värde motsvarar varje register.

Fragmentet: [0: count] behövs, eftersom den här metoden returnerar fler värden än count. Det returnerar alltid mängden värden som är delbart med 8. Ytterligare värden är falska och motsvarar inte något register.

Läs våra booleska värden med båda metoderna:

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

Resultatet blir så här: EXEMPEL

Sant hänvisar till 1 värde, falskt till 0.

4) Läs register

Läs nu värden från register skrivna med 6 funktion.

För att läsa register med funktion 3 läs innehavsregister, kör:

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

För att läsa register med funktion 4 läs ingångsregister, kör:

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

var:

• slav -id - id för virtuell slav
• register - registreringsnummer för läsning
• count - antal register som ska läsas
• signerad - anger om läsvärden ska behandlas som signerade nummer eller inte. Standardläge: Sant

Returvärdet är en tupel med önskad mängd register.

Läs register som ställts in i föregående punkt:

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)

Resultaten ska se ut på denna skärmdump: EXEMPEL

I nästa lektion lär du dig hur du skapar Modbus RTU Master på ESP32-aktiverad enhet.