ESP32 Modbus Maître TCP : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Dans cette classe, vous programmerez le processeur ESP32 comme maître Modbus TCP.

Nous utiliserons deux appareils, qui contiennent ce processeur: Moduino ESP32 et Pycom. Les deux appareils s'exécutent dans l'environnement MicroPytthon. Notre esclave Modbus sera un ordinateur PC avec un logiciel de simulation Modbus exécuté dessus.

Tu auras besoin de:

• Appareil Moduino ESP32 ou Moduino Pycom (consultez ce site Web pour en savoir plus sur l'appareil Moduino ESP32 et ceci pour vérifier l'appareil Pycom)
• PC avec système d'exploitation Linux
• Port RS-232/RS-485 de votre ordinateur ou convertisseur USB vers RS-232/RS-485

Étape 1: Téléchargez et démarrez le simulateur d'esclave Modbus TCP

Téléchargez le simulateur Modbus Slave sur https://www.modbusdriver.com/diagslave.html. Ouvrez ensuite l'archive téléchargée et décompressez la version pour le système d'exploitation Linux.

Exécutez le programme depuis la console avec l'argument -p:

./diagslave -p

est un port sur lequel le serveur Modbus Slave fonctionnera. Pour le protocole Modbus, il s'agit par défaut de 502, mais vous pouvez en utiliser un autre.

Sous Linux, les ports inférieurs à 1024 ne peuvent pas être utilisés par des programmes exécutés à partir d'un utilisateur normal (pas de privilèges root).

Rappelez-vous quel port vous utilisez. Cette valeur sera nécessaire plus tard.

Étape 2: préparez votre ordinateur à se connecter à l'appareil

Vous aurez besoin de certains programmes pour vous connecter à l'appareil et lui envoyer des fichiers.

Installez l'environnement Python et pip (si vous ne l'avez pas):

apt-get installer python3

apt-get install python3-dev curl "https://bootstrap.pypa.io/get-pip.py" -o "get-pip.py" python3 get-pip.py

Installez picocom:

apt-get installer picocom

Ce programme est nécessaire pour se connecter à l'appareil et exécuter des commandes dessus. Installez mpfshell:

pip installer mpfshell

Ce programme vous permet d'envoyer des fichiers à l'appareil.

Vous pouvez également l'installer à partir des sources. Référez-vous à cette page:

Étape 3: préparer l'appareil et s'y connecter

Pour connecter un périphérique Moduino ou Pycom à un PC, vous avez besoin d'un port ou d'un convertisseur RS-232/RS-485. Vérifiez la version de votre appareil (le type de port qu'il utilise) et trouvez le port ou le convertisseur approprié.

1. Connecter l'appareil au PC
2. Ensuite, connectez-y l'alimentation

Connectez l'appareil au PC, puis connectez-y l'alimentation. Vous pouvez également connecter un câble Ethernet à Moduino ESP32 (s'il possède ce port).

La connexion devrait être comme sur les photos ci-dessus

Recherchez le chemin du port, qui est utilisé pour la connexion de l'appareil. Il peut s'agir par exemple: /dev/ttyS1, /dev/ttyUSB0.

Pour les convertisseurs USB, le chemin contiendra le mot USB.

Vous pouvez vous connecter à l'appareil avec le programme picocom:

picocom /dev/ttyUSB0 -b 115200

L'invite de commande de l'appareil ressemble à l'une de ces images ci-dessous.

Moduino ESP32: voir ici

Moduino Pycom: voir ici

Étape 4: télécharger la bibliothèque principale Modbus

github.com/pycom/pycom-modbus/Pour communiquer avec l'esclave Modbus, vous avez besoin d'une bibliothèque appropriée. Les bibliothèques pour Pycom ne sont pas compatibles avec Moduino. Vérifiez les instructions qui sont conformes à votre appareil.

Fermez picocom avant d'envoyer des fichiers: appuyez sur Ctrl+A puis sur les touches Ctrl+X.

La bibliothèque uModBus pour Moduino ESP32 se base sur la bibliothèque pycom-modbus pour Moduino Pycom. Il est modifié pour fonctionner sur un appareil ESP32 standard. Il a également des méthodes close() supplémentaires pour les classes de connecteur.

1) Moduino ESP32

Téléchargez la bibliothèque à partir de https://github.com/techbase123/micropython-modbus. Décompressez l'archive et envoyez les 4 fichiers à l'appareil Moduino.

Utilisez mpfshell pour les télécharger. Exécutez ce programme dans le répertoire avec ces fichiers.

Connectez-vous à l'appareil en exécutant: CECI

ttyUSB0 est le nom du port série auquel le périphérique est connecté.

Changez de répertoire en /flash/lib avec la commande:

cd/flash/lib

Mettez tous les fichiers avec les commandes:

mettre uModBusConst.py

mettre uModBusFunctions.py mettre uModBusTCP.py mettre uModBusSerial.py

EXEMPLE

Quittez ensuite la console avec la commande exit et redémarrez l'appareil avec le bouton Reset.

2) Moduino Pycom

Téléchargez la bibliothèque sur https://github.com/pycom/pycom-modbus/. Décompressez l'archive et envoyez le contenu du répertoire uModbus à l'appareil. Utilisez mpfshell pour les télécharger. Exécutez ce programme dans le répertoire avec ces fichiers.

Connectez-vous à l'appareil en exécutant:

ouvrir ttyUSB0

ttyUSB0 est le nom du port série auquel le périphérique est connecté.

Changez le répertoire en /flash/lib, créez le répertoire uModbus et entrez-le avec les commandes:

cd /flash/libmd uModbus cd uModbus

Mettez tous les fichiers avec les commandes:

mettre const.py

mettre fonctions.py mettre tcp.py mettre serial.py

Quittez ensuite la console avec la commande exit et redémarrez l'appareil avec le bouton Reset.

EXEMPLE

Étape 5: Se connecter au réseau

Les commandes pour établir la connexion diffèrent entre Moduino et Pycom.

Connectez-vous à l'appareil avec picocom pour exécuter les commandes appropriées. Vous pouvez connecter l'appareil Moduino au réseau par fil ou sans fil. Les exemples suivants supposent que votre réseau dispose d'un serveur DHCP fonctionnel.

Dans d'autres cas, l'appareil n'obtiendra pas d'adresse IP. La prise en charge WiFi est disponible dans chaque Moduino. Le port Ethernet est une option et tous les appareils ne l'ont pas.

1) Moduino ESP32

Connexion au Wi-Fi

Exécutez les commandes suivantes sur l'appareil:

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

Remplacez ESSID par le nom de votre réseau WiFi et PASS par le mot de passe de celui-ci.

Après un certain temps après l'exécution de start(), vous devriez obtenir une adresse IP qui a été attribuée à votre appareil.

Connexion au réseau Ethernet

Connectez l'appareil au réseau filaire avec un câble Ethernet.

Exécutez ensuite les commandes suivantes:

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

Après un certain temps après l'exécution de start(), vous devriez obtenir l'adresse IP qui a été attribuée à votre appareil.

2) Moduino Pycom

Se connecter au Wi-Fi

Exécutez les commandes suivantes sur l'appareil:

à partir de l'importation réseau WLANwlan = WLAN(mode=WLAN. STA) nets = wlan.scan() pour net dans nets:if net.ssid == 'ESSID': print('Network found!') wlan.connect(net.ssid, auth=(net.sec, 'PASS'), timeout=5000) sans wlan.isconnected(): machine.idle() print('WLAN connexion réussie !') break

Remplacez ESSID par le nom de votre réseau WiFi et PASS par le mot de passe de celui-ci.

Étape 6: Initialiser la communication avec l'esclave Modbus

Les bibliothèques Modbus Master sont similaires pour les deux appareils

Ils varient dans l'initialisation.

1) Initialiser uModBus sur Moduino ESP32

Exécuter:

depuis uModBusTCP importer uModBusTCP en tant que TCP

2) Initialiser uModBus sur Pycom

Exécuter:

depuis uModbus.tcp importer TCP

Connexion ouverte

Ensuite, ouvrez la connexion avec:

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

où:

• IP - adresse ip de votre PC avec simulateur Modbus Slave
• PORT - port de l'esclave Modbus
• 60 est un délai d'attente

Si l'erreur suivante se produit lors de l'exécution des commandes de lecture/écriture: EXEMPLE

exécuter:

pour Moduino ESP32:

modbus.close()

pour Moduino Pycom:

modbus._sock.close()

puis recréez la connexion:

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

Il est important de fermer le socket avant de recréer la connexion. L'appareil a une quantité limitée de connexions de socket disponibles.

Étape 7: lire et écrire des registres

Modbus prend en charge plusieurs fonctions pour lire et écrire des registres.

La bibliothèque uModBus a une méthode pour chaque fonction:

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

Tout d'abord, écrivons quelques valeurs.

1) Écrire des bobines (fonction: 5)

Écrire 1 valeur dans le registre 200 à partir de l'esclave 1:

modbus.write_single_coil (1, 200, 0xFF00)

Le premier argument est pour l'identifiant de l'esclave, dans notre cas 1.

Le deuxième est le numéro de registre et le troisième est une valeur. Pour 1, vous devez mettre 0xFF00 ici. Ecrire le registre 0 à 201 depuis l'esclave 1:

modbus.write_single_coil (1, 201, 0)

Cette méthode permet d'écrire uniquement des valeurs booléennes: 0 ou 1.

2) Ecrire des registres (func: 6)

Écrivez maintenant des valeurs entières dans plusieurs registres.

Écrire la valeur 111 signée dans le registre 100 à partir de l'esclave 1:

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

Le premier argument est l'identifiant de l'esclave, le deuxième numéro de registre et le troisième est la nouvelle valeur. Le dernier argument définit si la valeur doit être définie comme un nombre signé. La valeur par défaut est True. Vous n'avez pas besoin de le définir.

Écrire la valeur -457 signée dans le registre 101 à partir de l'esclave 1:

modbus.write_single_register (1, 101, -457)

Écrire la valeur 50 non signée dans le registre 100 de l'esclave 3:

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

Cette méthode permet d'écrire des valeurs entières dans un seul registre.

Un seul registre peut contenir des valeurs de 16 bits.

La méthode renvoie True si la valeur d'entrée est valide et False sinon. La valeur est écrite même si elle est invalide (trop grande pour le registre)

3) Lire les bobines/entrées discrètes

Lisons maintenant les valeurs booléennes écrites. Pour lire le registre avec la fonction 1 read coil, exécutez:

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

Pour lire le registre avec la fonction 2 lire l'entrée TOR, exécutez:

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

où:

• slave-id - identifiant de l'esclave virtuel (le simulateur d'esclave accepte tous les identifiants valides)
• registre - numéro de registre pour la lecture
• count - nombre de registres à lire (mettre le montant souhaité aux deux endroits)

Ces méthodes renvoient un tableau avec des valeurs booléennes. Chaque valeur correspond à chaque registre.

Le fragment: [0:count] est nécessaire, car cette méthode renvoie plus de valeurs que count. Il renvoie toujours un nombre de valeurs divisible par 8. Les valeurs supplémentaires sont False et ne correspondent à aucun registre.

Lisez nos valeurs booléennes avec les deux méthodes:

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

Le résultat sera comme ceci: EXEMPLE

True fait référence à 1 valeur, False à 0.

4) Lire les registres

Maintenant, lisez les valeurs des registres écrits avec la fonction 6.

Pour lire les registres avec la fonction 3 read holding registers, exécutez:

modbus.read_holding_registers(slaveId, enregistrer, compter, signé=True)

Pour lire les registres avec la fonction 4 lire les registres d'entrée, exécutez:

modbus.read_input_registers(slaveId, enregistrer, compter, signé=True)

où:

• slave-id - identifiant de l'esclave virtuel
• registre - numéro de registre pour la lecture
• count - nombre de registres à lire
• signé - indique si les valeurs lues doivent être traitées comme des nombres signés ou non. État par défaut: vrai

La valeur de retour est un tuple avec le nombre de registres souhaité.

Lire les registres définis au point précédent:

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)

Les résultats devraient ressembler à cette capture d'écran: EXEMPLE

Dans la leçon suivante, vous apprendrez à créer un maître Modbus RTU sur un appareil compatible ESP32.