Différences entre les versions de « Modbus et IPX800 V5 »

De GCE Electronics
Aller à la navigation Aller à la recherche
 
(75 versions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
{{sommaire|niveau=4|flottant=left}}
{{sommaire|niveau=4|flottant=left}}
<small>''<sub>changes à faire : traitement des valeurs négatives par complément ????</sub>''</small>
==Introduction==
{{Infobox IPX800
{{Infobox IPX800
  | titre        = Modbus
  | titre        = Modbus
Ligne 11 : Ligne 5 :
  | famille      = IPX800 V5
  | famille      = IPX800 V5
  | date-create  = 11/09/2024
  | date-create  = 11/09/2024
  | date-update  = 11/09/2024
  | date-update  = 21/09/2024
  | auteur = fgtoul<br>
  | auteur = fgtoul<br>
}}
}}


Nous allons explorer un sujet technique qui pourrait sembler intimidant pour certains. Hier encore, j'étais dans le même bateau, jusqu'à ce qu'un véritable chevalier blanc vienne chez moi pour me donner quelques leçons et m'aider à y voir plus clair. Un grand merci à @Jweb pour son aide précieuse !
==Introduction==
Nous allons explorer un sujet technique qui pourrait sembler intimidant pour certains. J'étais dans le même bateau, jusqu'à ce qu'un chevalier blanc m'explique les bases ! Merci @Jweb !


Aujourd'hui, je ne prétends pas être un expert en la matière, mais je souhaite partager ce que j'ai appris pour vous aider à  l'intégration de ces appareils dans votre installation sans vous laisser décourager par le protocole Modbus.
Aujourd'hui, je ne prétends pas être un expert en la matière, mais je souhaite partager ce que j'ai appris pour vous aider à  l'intégration de ces appareils dans votre installation sans vous laisser décourager par le protocole Modbus.


Ce qui va suivre n'est pas un guide exhaustif sur le protocole Modbus, mais plutôt une explication simplifiée adaptée à nos configurations utilisant les IPX800 V5.  
Ce qui va suivre n'est pas un guide exhaustif sur le protocole Modbus, mais plutôt une explication simplifiée adaptée à nos configurations utilisant les IPX800 V5.


==Historique==
==Historique==
Ligne 27 : Ligne 22 :


À l’origine, Modbus permettait les communications sur un bus filaire série. Cependant, les contraintes de ce mode de communication ont conduit à des évolutions telles que Modbus TCP, qui permet des communications sur des distances beaucoup plus longues et avec un nombre de périphériques théoriquement illimité.
À l’origine, Modbus permettait les communications sur un bus filaire série. Cependant, les contraintes de ce mode de communication ont conduit à des évolutions telles que Modbus TCP, qui permet des communications sur des distances beaucoup plus longues et avec un nombre de périphériques théoriquement illimité.
Les commandes disponibles ont été définies selon les besoins du moment. Elles sont restées identiques à ce jour.
Nous retrouverons donc 4 grandes familles :
* Les entrées discrètes (discrete inputs) : Ce sont des entrées tout ou rien (TOR) comme des boutons, capteurs,, représentées par une valeur booléenne.En Modbus Il est possible de traiter jusqu'à 2000 valeurs en 1 seule commande, l'IPX800 imposera ses propres limitations. Accessibles en lecture seule.
* Les bobines (coils) : ce sont les sorties TOR. Nous les utiliserons pour piloter des relais, contacteurs, ....  Elles sont représentées par des valeurs booléennes. Le protocole stipule qu'Il est possible de traiter jusqu'à 2000 valeurs en une seule commande,  l'IPX800 imposera ses propres limitations. Accessibles en lecture écriture.
* Les registres d'entrées : ce sont des zones mémoire permettant la saisie de valeurs numériques représentées par des mots de 16 bits. Il est possible de traiter jusqu'à 125 registres en une seule commande,  l'IPX800 imposera ses propres limitations. Accessibles en lecture seule.
* Les registres de maintien : zones mémoire pour mémoriser ou ressortir des valeurs numériques représentées par des mots de 16 bits. Il est possible de traiter jusqu'à 125 registres en une seule commande,  l'IPX800 imposera ses propres limitations .Accessibles en lecture/écriture.


==RTU vs TCP==
==RTU vs TCP==
Ligne 70 : Ligne 76 :
Modbus TCP/IP fonctionne sur des réseaux Ethernet, permettant une communication plus rapide et une intégration facile avec les réseaux informatiques existants.
Modbus TCP/IP fonctionne sur des réseaux Ethernet, permettant une communication plus rapide et une intégration facile avec les réseaux informatiques existants.


Cette architecture  Maître/Esclaves fonctionne en mode full-duplex, permettant l’envoi et la réception de données simultanément dans les deux sens. Cela améliore la vitesse et l’efficacité de la communication.
Plusieurs maîtres peuvent communiquer sur un même réseau.
 
Cette architecture  Maîtres/Esclaves fonctionne en mode full-duplex, permettant l’envoi et la réception de données simultanément dans les deux sens. Cela améliore la vitesse et l’efficacité de la communication.
 


    
    
Ligne 99 : Ligne 108 :
==Modbus RTU==
==Modbus RTU==
===Le maître===
===Le maître===
Notre IPX800 V5 possède tous les outils pour interroger ou piloter des dispositifs sur son réseau Modbus.
Notre IPX800 V5 possède tous les outils pour interroger ou piloter des dispositifs sur son réseau Modbus.  


Un maître peut envoyer des requêtes de lecture ou d'écriture de données vers un dispositif particulier grâce à l'adresse unique qui identifie chaque esclave (1 à 247). L'esclave répond à la requête.
L'IPX800 peut envoyer des requêtes de lecture ou d'écriture de données vers un dispositif particulier grâce à l'adresse unique qui identifie chaque esclave (1 à 247). L'esclave répond à la requête.


[[Fichier:RTU requête simple.png|sans_cadre|500x500px]]
[[Fichier:RTU requête simple.png|sans_cadre|500x500px]]


Il peut également s'adresser à tous les esclaves simultanément en envoyant un Broadcast sur l'adresse 0 ou 254. Les esclaves ne répondent pas.  
Il peut également s'adresser à tous les esclaves simultanément en envoyant un message de diffusion (Broadcast) sur l'adresse 0 ou 254. Les esclaves ne répondent pas.  


Vu que tous les esclaves ne peuvent pas répondre simultanément, le broadcast est utilisé pour l'envoi de commandes d'écriture.
Vu que tous les esclaves ne peuvent pas répondre simultanément, le broadcast est utilisé pour l'envoi de commandes d'écriture.


[[Fichier:Image broadcast RTU.png|sans_cadre|507x507px]]
[[Fichier:Image broadcast RTU.png|sans_cadre|507x507px]]
'''NB : L'IPX800 est maître et doit être le seul maître sur le bus série.'''


===L'esclave===
===L'esclave===
Chaque esclave est identifié par son adresse réseau unique.  
Chaque esclave est identifié par son adresse réseau unique(ID). L'esclave, comme nous l'avons abordé plus haut, ne peut prendre aucune initiative. Il reste en veille jusqu'à réception d'une requête émise par le maître. Si la requête lui est bien adressée (son adresse réseau unique correspond), il traite la demande et renvoie une réponse au maître. Il traitera également toute demande envoyée sous forme de Broadcast.
L'esclave, comme nous l'avons abordé plus haut, ne peut prendre aucune initiative. Il reste en veille jusqu'à réception d'une requête émise par le maître. Si la requête lui est bien adressée (son adresse réseau unique correspond), il traite la demande et renvoie une réponse au maître. Il traitera également la demande dans le cas d'un Broadcast.
 
 
 
Certains esclaves modbus RTU comportent 2 ports série distincts leur permettant alors de communiquer avec 2 maîtres, sans que les bus RS485 ne soient fusionnés.
 
[[Fichier:Image esclave rtu 2 ports.png|sans_cadre|652x652px]]
 
===  Mise en œuvre sur IPX800 V5 ===
L'ipx800 V5 dispose de 2 objets permettant d'émettre ou recevoir des trames Modbus RTU. Nous verrons l'utilisation de ces objets dans le paragraphe suivant.
 
<u>'''Objet Modbus read'''</u>
 
Cet objet permet de traiter les fonction 1,2,3 et 4. Il est possible de lire jusqu'à 48 octets.
 
[[Fichier:Image modbus read 00.png|sans_cadre|903x903px]]
 
La construction de la structure du champ de données est faite à partir de tuiles IO ou analoqiques qui sont déposées dans le conteneur drag&drop [[Fichier:Image drag-drop.png|sans_cadre|41x41px]].
 
Ces mêmes tuiles définissent alors les variables qui seront utilisées pour stocker les valeurs contenues dans la réponse de l'esclave.
 
Vous pourrez alors utiliser ces variables dans vos règles et liens.
 
'''<u>Objet Modbus Write</u>'''
 
Cet objet permet de traiter les requêtes 5, 6, 15 et 16.
 
[[Fichier:Image modbus write 00.png|sans_cadre|903x903px]]
 
La construction des données à écrire se fait à partir des tuiles IO et analogiques que vous déposez dans le conteneur drag&drop [[Fichier:Image drag-drop.png|sans_cadre|41x41px]].
 
Vous devez alors prévoir de valoriser chaque variable avant l'envoi de la requête. Cette valorisation peut se faire par règle ou lien, comme n'importe quelle ressource.
   
   
===Les requêtes===
===Les requêtes===
En Modbus RTU, les messages sont encapsulés dans un format binaire compact et transmis via des interfaces série (RS485 pour notre IPX).
En Modbus, les messages sont encapsulés dans un format binaire compact et transmis via des interfaces série (RS485 pour notre IPX).


Chaque message contient une adresse d’esclave, un code de fonction, des données et un CRC (Cyclic Redundancy Check) pour la vérification des erreurs.
Chaque message contient une adresse d’esclave, un code de fonction, des données et un CRC (Cyclic Redundancy Check) pour la vérification des erreurs.




Chaque octet de la trame RTU est codé sur 2 caractères hexadécimaux. La trame sera composée de 256 octets maximum.
Chaque octet de la trame Modbus est codé sur 2 caractères hexadécimaux. La trame sera composée de 256 octets maximum.
{| class="wikitable"
{| class="wikitable"
|+
|+
Ligne 147 : Ligne 188 :
Pour connaître les requêtes utilisables sur votre appareil esclave, vous devrez vous référer à la documentation du fabricant.
Pour connaître les requêtes utilisables sur votre appareil esclave, vous devrez vous référer à la documentation du fabricant.


  Remarque :
  '''L'adressage :'''
  Vous remarquerez que l'esclave détermine le début et la fin d'une trame grâce à 2 silences. Ces silences doivent avoir chacun une durée équivalente à celle de la transmission de 3.5 caractères (1 caractère=11 bits).
  A l'origine, la mémoire était organisée par catégorie de matériel pilotable, elle était divisée en 4 zones.  
   
   
  Avec une vitesse de transmission de 9600 Bauds, le silence doit donc durer 3.5 * 11 * (1/9600) secondes, soit environ 4 millièmes de secondes.
  * Bobines. Lecture/écriture: 00001 à 09999
* Entrées discrètes. lecture seule: 10001 à 19999
* Registres d'entrées. Lecture seule: 30001 à 39999
* Registres de maintien. Lecture/écriture: 40001 à 49999
   
   
  C'est pourquoi, lors de la programmation de l'ipx800, il faut éviter de traiter plus de 2 requêtes sur une même règle. Par défaut l'ipx800 insère des silences de 5ms permettant d'écouter le bus et peut stocker jusqu'à 2 trames sans problème. Mais si vous surchargez la règle avec plus de 2 requêtes, l'IPX pourrait envoyer les trames trop rapprochées les unes des autres, il y aurait alors risque de perte d'informations. Il deviendrait alors judicieux d'ajouter des objets "Délais" entre les émissions de trames afin de permettre l'écoute du bus et le traitement des réponses.
  Cependant, avec les avancées technologiques, la structure des mémoires de stockage a évolué et chaque fabricant peut organiser la mémoire interne comme il l'entend. Il doit donc fournir une table d'adresses à utiliser pour chaque équipement.<br />


'''Les données :'''
Les données numériques sont toujours transmises sous forme d'entiers. Le fabricant fournit le format numérique afin de convertir la donnée brute en donnée exploitable. Par exemple, il communiquera le nombre de décimales (e.g gain=0.1). Il faudra alors faire la conversion lors de la réception de la valeur sur le maître.
'''Remarque :'''
Dans le tableau ci-dessus, vous remarquerez que l’esclave détermine le début et la fin d’une trame grâce à deux silences. Ces silences doivent chacun avoir une durée équivalente à celle de la transmission de 3,5 caractères (1 caractère = 11 bits).
Avec une vitesse de transmission de 9600 bauds, le silence doit donc durer 3,5 * 11 * (1/9600) secondes, soit environ 4 millisecondes.
C’est pourquoi, lors de la programmation de l’IPX800, il faut éviter de traiter plus de deux requêtes dans une même règle. De même, il est préférable de ne pas lier plus de deux requêtes à une même ressource ou événement. Par défaut, l’IPX800 insère des silences de 5 ms permettant d’écouter le bus et peut stocker jusqu’à deux trames sans problème. Cependant, si vous surchargez la règle avec plus de deux requêtes, l’IPX pourrait envoyer les trames trop rapprochées les unes des autres, ce qui risquerait de provoquer une perte d’informations. Il devient alors judicieux d’ajouter des objets “Délais” entre les émissions de trames afin de permettre l’écoute du bus et le traitement des réponses.


==== les différents codes de fonction====
==== les différents codes de fonction====
Il y a 19 fonctions en tout, voici les principales.
Il y a 19 fonctions en tout, voici les principales prises en charge par l'ipx800 V5


=====Requêtes de lecture=====
=====Requêtes de lecture. =====
Lecture des bits de sortie (coils) :0x01
Les requêtes de lecture sont facilement mises en œuvre sur l'IPX800 grâce à l'objet "'''Modbus Read'''". Cet objet permet la sélection de l'une des 4 fonctions détaillées ci-dessous.
Description : Lire l’état des bits de sortie (coils) des esclaves.


Lecture des entrées discrètes :0x02
====== Lecture des bits de sortie (coils) 0x01 : ======
La fonction 01 en Modbus RTU est utilisée pour '''lire l’état des bobines''' (coils) d’un dispositif esclave. Les bobines sont des éléments binaires qui peuvent être soit activés (1) soit désactivés (0). Cette fonction permet au maître Modbus de vérifier l’état de ces bobines pour des opérations de contrôle et de surveillance.
 
'''<u>Détails de la Fonction 1</u>'''
 
* '''Code de Fonction''': 01 (0x01 en hexadécimal)
* '''Description''': Lecture de l’état des bobines
* '''Utilisation''': Permet au maître de lire l’état de plusieurs bobines dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse 1ere  bobine
!Nombre de bobines à lire
!CRC
|-
| 1 octet
|01
|2 octets
|2 octets
| 2 octets
|}
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons lire l’état de 10 bobines à partir de l’adresse 0x0013 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x01
* '''Adresse de la première bobine''': 0x0013
* '''Nombre de bobines''': 0x000A
 
La trame de requête serait :
 
<code><big>01 01 00 13 00 0A</big></code>
 
'''<u>Structure de la Trame de Réponse.</u>'''
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Nombre d'octets à suivre
!Valeurs des bobines lues
!CRC
|-
| 1 octet
|01
|1 octet
| n octets
|2 octets
|}
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, si les 10 bobines ont les états suivants : 11001101 01, la trame de réponse serait :
 
<code><big>01 01 02 CD 01</big></code>
 
où <code>CD</code> représente les 8 premières bobines (11001101 en binaire) et <code>01</code> les 2 dernières (01 en binaire).
 
Ces trames montrent comment la fonction 1 est utilisée pour lire l’état des bobines dans un appareil esclave en Modbus RTU
 
 
 
'''<u>Mise en œuvre sur IPX</u>'''
 
Pour cet exemple, nous devons lire l'état de 10 bobines,  c'est à dire 10 bits consécutifs. Nous pouvons utiliser des tuiles de type IO que nous pourrons nommer et utiliser individuellement dans notre système domotique.
 
L'adresse de début est 19 en décimal (13 en hexa).
 
[[Fichier:Modbus read rtu 01.png|sans_cadre|940x940px]]
 
====== Lecture des entrées discrètes :0x02 ======
Description : Lire l’état des entrées discrètes (discrete inputs) des esclaves.
Description : Lire l’état des entrées discrètes (discrete inputs) des esclaves.


Lecture des registres d’entrée : 0x04
La fonction 02 en Modbus RTU est utilisée pour '''lire l’état des entrées discrètes''' (input status) d’un dispositif esclave. Les entrées discrètes sont des éléments binaires similaires aux bobines, mais elles sont généralement utilisées pour lire des états de capteurs ou d’autres dispositifs d’entrée.
Description : Lire les valeurs des registres d’entrée (input registers) des esclaves.
 
'''<u>Détails de la Fonction 2</u>'''
 
* '''Code de Fonction''': 02 (0x02 en hexadécimal)
* '''Description''': Lecture de l’état des entrées discrètes
* '''Utilisation''': Permet au maître de lire l’état de plusieurs entrées discrètes dans l’esclave.
 
<u>'''Structure de la Trame de Requête'''</u>
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse 1ere  entrée
!Nombre d'entrées à lire
!CRC
|-
| 1 octet
|02
|2 octets
|2 octets
| 2 octets
|}
 
 
 
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons lire l’état de 10 entrées discrètes à partir de l’adresse 0x0013 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x02
* '''Adresse de la première entrée''': 0x0013
* '''Nombre d’entrées''': 0x000A
 
La trame de requête serait :
 
<code><big>01 02 00 13 00 0A</big></code>
 
'''<u>Structure de la Trame de Réponse</u>'''
 
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Nombre d'octets à suivre
!Valeurs des entrées lues
!CRC
|-
| 1 octet
|02
|1 octet
| n octets
|2 octets
|}
 
 
 
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, si les 10 entrées discrètes ont les états suivants : 11001101 01, la trame de réponse serait :
 
<code><big>01 02 02 CD 01</big></code>
 
où <code>CD</code> représente les 8 premières entrées (11001101 en binaire) et <code>01</code> les 2 dernières (01 en binaire).
 
'''<u>Mise en œuvre sur IPX800</u>'''
 
[[Fichier:Modbus Read RTU 02.png|sans_cadre|940x940px]]
 
====== Lecture des registres de maintien : 0x03 ======
La fonction 03 en Modbus RTU est utilisée pour '''lire les registres de maintien''' (holding registers) d’un dispositif esclave. Les registres de maintien sont des emplacements de mémoire utilisés pour stocker des données telles que des paramètres de configuration ou des valeurs de processus.
 
'''<u>Détails de la Fonction 3</u>'''
 
* '''Code de Fonction''': 03 (0x03 en hexadécimal)
* '''Description''': Lecture des registres de maintien
* '''Utilisation''': Permet au maître de lire les valeurs de plusieurs registres de maintien dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse 1er  registre
!Nombre de registres à lire
!CRC
|-
| 1 octet
|03
|2 octets
|2 octets
|2 octet
|}
 
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons lire les valeurs de 3 registres à partir de l’adresse 0x0001 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x03
* '''Adresse du premier registre''': 0x0001
* '''Nombre de registres''': 0x0003
 
La trame de requête serait :
 
<code><big>01 03 00 01 00 03</big></code>
 
'''<u>Structure de la Trame de Réponse</u>'''
 
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Nombre d'octets
!valeurs des registres lus
!CRC
|-
| 1 octet
|03
|1 octet
| n octets
|2 octets
|}
 
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, si les valeurs des 3 registres sont 0x000A, 0x000B, et 0x000C, la trame de réponse serait :
 
<code><big>01 03 06 00 0A 00 0B 00 0C</big></code>
 
où <code>06</code> représente le nombre d’octets de données (3 registres x 2 octets chacun).
 
 
 
'''<u>Mise en œuvre sur IPX800</u>'''
 
[[Fichier:Modbus read rtu 03.png|sans_cadre|940x940px]]
 
======Lecture des registres d’entrée : 0x04======
La fonction 4 en Modbus RTU, également connue sous le code 0x04, est utilisée pour '''lire les registres d’entrée''' (input registers) d’un appareil esclave. Cette fonction permet au maître de lire les valeurs de plusieurs registres d’entrée en une seule commande.
 
'''<u>Détails de la Fonction 4</u>'''
 
* '''Code de Fonction''': 04 (0x04 en hexadécimal)
* '''Description''': Lecture des registres d’entrée
* '''Utilisation''': Permet au maître de lire les valeurs de plusieurs registres d’entrée dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse 1er  registre
!Nombre de registres à lire
!CRC
|-
| 1 octet
|04
|2 octets
|2 octets
| 2 octets
|}
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons lire les valeurs de 3 registres d’entrée à partir de l’adresse 0x0001 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x04
* '''Adresse du premier registre''': 0x0001
* '''Nombre de registres''': 0x0003
 
La trame de requête serait :
 
<code><big>01 04 00 01 00 03</big></code>
 
'''<u>Structure de la Trame de Réponse</u>'''
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Nombre d'octets de données à suivre
!Valeurs de registres lues
!CRC
|-
| 1 octet
|04
|1 octet
| n octets
|2 octets
|}
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, si les valeurs des 3 registres sont 0x000A, 0x000B, et 0x000C, la trame de réponse serait :
 
<code><big>01 04 06 00 0A 00 0B 00 0C</big></code>
 
où <code>06</code> représente le nombre d’octets de données (3 registres x 2 octets chacun).
 


Lecture des registres de maintien : 0x03
 
Description : Lire les valeurs des registres de maintien (holding registers) des esclaves.
'''<u>Mise en œuvre sur IPX800</u>'''
 
[[Fichier:Modbus read rtu 04.png|sans_cadre|941x941px]]


=====Requêtes d’écriture=====
=====Requêtes d’écriture=====
Écriture d’un bit de sortie unique : 0x05
Les requêtes d'écriture sont mises en œuvre sur l'IPX800 grâce à l'objet "'''Modbus Write'''". Cet objet permet la sélection de l'une des 4 fonctions détaillées ci-dessous.
Description : Écrire une valeur dans un bit de sortie (coil) unique.


Écriture d’un registre de maintien unique : 0x06
====== Écriture d’un bit de sortie unique : 0x05 ======
Description : Écrire une valeur dans un registre de maintien (holding register) unique.


Écriture de plusieurs bits de sortie : 0x0F
Description : Écrire des valeurs dans plusieurs bits de sortie (coils).


Écriture de plusieurs registres de maintien : 0x10
La fonction 5 en Modbus RTU, également connue sous le code 0x05, est utilisée pour '''écrire une seule bobine''' (single coil) dans un appareil esclave1. Cette fonction permet au maître de définir l’état (ON ou OFF) d’une bobine spécifique.
Description : Écrire des valeurs dans plusieurs registres de maintien (holding registers).
 
'''<u>Détails de la Fonction 5</u>'''
 
* '''Code de Fonction''': 05 (0x05 en hexadécimal)
* '''Description''': Écriture d’une seule bobine
* '''Utilisation''': Permet au maître de modifier l’état d’une bobine spécifique dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse de la bobine
!valeur à écrire
!CRC
|-
| 1 octet
|05
|2 octets
|2 octets
| 2 octets
|}
 
 
 
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons écrire la valeur ON (0xFF00) dans la bobine à l’adresse 0x0001 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x05
* '''Adresse de la bobine''': 0x0001
* '''Valeur à écrire''': 0xFF00
 
La trame de requête serait :
 
<code><big>01 05 00 01 FF 00</big></code>
 
'''<u>Structure de la Trame de Réponse</u>'''
 
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Adresse de la bobine
!Valeur écrite dans la bobine
!CRC
|-
| 1 octet
|05
|2 octets
| 2 octets
|2 octets
|}
 
 
 
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, la trame de réponse serait identique :
 
<code><big>01 05 00 01 FF 00</big></code>
 
 
 
'''<u>Mise en œuvre sur IPX800</u>'''
 
[[Fichier:Modbus write rtu 05.png|sans_cadre|940x940px]]
 
La première analogique 8 bits sera valorisée à 255 (FF en hexa), la seconde à 0.
 
Nous pouvons aussi utiliser une variable 16 bits. Dans ce cas elle serait valorisée à 65280 (FF 00 en hexa).
 
====== Écriture d’un registre de maintien unique : 0x06 ======
La fonction 06 en Modbus RTU est utilisée pour écrire une valeur dans un registre de maintien (holding register) d’un appareil esclave. Voici quelques détails supplémentaires et des exemples de trames pour illustrer son utilisation.
 
'''<u>Détails de la Fonction 06</u>'''
 
* '''Code de Fonction''': 06
* '''Description''': Écriture d’un seul registre de maintien
* '''Utilisation''': Permet au maître de modifier la valeur d’un registre spécifique dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse du registre à écrire
!valeur à écrire
!CRC
|-
| 1 octet
|06
|2 octets
|2 octets
| 2 octets
|}'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons écrire la valeur 0x00FF dans le registre à l’adresse 0x0001 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x06
* '''Adresse du registre''': 0x0001
* '''Valeur à écrire''': 0x00FF
 
La trame de requête serait :
 
<code><big>01 06 00 01 00 FF</big></code>
 
'''<u>Structure de la Trame de Réponse</u>'''
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Adresse du registre écrit
!Valeur écrite dans le registre
!CRC
|-
| 1 octet
|06
|2 octets
| 2 octets
|2 octets
|}
 
 
 
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, la trame de réponse serait identique :
 
<code><big>01 06 00 01 00 FF</big></code>
 
 
 
'''<u>Mise en œuvre sur ipx800</u>'''
 
[[Fichier:Modbus write rtu 06.png|sans_cadre|940x940px]]
 
La 1ère variable 8 bits sera valorisée à ca0, la seconde à 255 (FF en hexa).
 
Nous pouvons aussi utiliser une variable 16 bits valorisée à 255.
 
====== Écriture de plusieurs bits de sortie : 0x0F ======
La fonction 0F en Modbus RTU est utilisée pour '''écrire plusieurs bobines''' (coils) dans un appareil esclave1. Cette fonction permet au maître de définir l’état (ON ou OFF) de plusieurs bobines en une seule commande.
 
'''<u>Détails de la Fonction 15</u>'''
 
* '''Code de Fonction''': 0F (15 en décimal)
* '''Description''': Écriture de plusieurs bobines
* '''Utilisation''': Permet au maître de modifier l’état de plusieurs bobines dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse de la 1ère bobine à écrire
! Nombre de bobines à écrire
!Nombre d'octets à suivre
! valeur des bobines à écrire
!CRC
|-
| 1 octet
|0F
|2 octets
|2 octets
|1 octet
|n octets
| 2 octets
|}
 
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons écrire les valeurs 0xCD (11001101 en binaire) dans 8 bobines à partir de l’adresse 0x0013 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x0F
* '''Adresse de la première bobine''': 0x0013
* '''Nombre de bobines''': 0x0008
* '''Nombre d’octets de données''': 0x01
* '''Valeurs des bobines''': 0xCD
 
La trame de requête serait :
 
<code><big>01 0F 00 13 00 08 01 CD</big></code>
 
 
'''<u>Structure de la Trame de Réponse</u>'''
 
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Adresse de la 1ère bobine écrite
!Nombre de bobines écrites
!CRC
|-
| 1 octet
|0F
|2 octets
| 2 octets
|2 octets
|}
 
 
 
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, la trame de réponse serait :
 
<code><big>01 0F 00 13 00 08</big></code>
 
 
 
'''<u>Mise en œuvre sur IPX800</u>'''
 
[[Fichier:Modbus write rtu 0F.png|sans_cadre|940x940px]]
 
avec chaque IO valorisée à  1 ou 0.
 
Nous pouvons également utiliser une variable 8 bits valorisée à 205 (CD en hexa)
 
====== Écriture de plusieurs registres de maintien : 0x10 ======
La fonction 10 en Modbus RTU, également connue sous le code 0x10, est utilisée pour '''écrire plusieurs registres de maintien''' (holding registers) dans un appareil esclave1. Cette fonction permet au maître de modifier les valeurs de plusieurs registres en une seule commande.
 
'''<u>Détails de la Fonction 10</u>'''
 
* '''Code de Fonction''': 10 (16 en décimal)
* '''Description''': Écriture de plusieurs registres de maintien
* '''Utilisation''': Permet au maître de modifier les valeurs de plusieurs registres dans l’esclave.
 
'''<u>Structure de la Trame de Requête</u>'''
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse du 1er registre à écrire
! Nombre de registres à écrire
!Nombre d'octets à suivre
! valeur des registres à écrire
!CRC
|-
| 1 octet
|10
|2 octets
|2 octets
|1 octet
|n octets
| 2 octets
|}
 
 
 
'''<u>Exemple de Trame de Requête</u>'''
 
Supposons que nous voulons écrire les valeurs 0x000A et 0x000B dans deux registres à partir de l’adresse 0x0010 de l’esclave avec l’adresse 0x01.
 
* '''Adresse de l’esclave''': 0x01
* '''Code de fonction''': 0x10
* '''Adresse du premier registre''': 0x0010
* '''Nombre de registres''': 0x0002
* '''Nombre d’octets de données''': 0x04
* '''Valeurs des registres''': 0x000A 0x000B
 
La trame de requête serait :
 
<code><big>01 10 00 10 00 02 04 00 0A 00 0B</big></code>
 
'''<u>Structure de la Trame de Réponse</u>'''
 
{| class="wikitable"
!Adresse de l'esclave
!code fonction
! Adresse du 1er registre écrit
!Nombre de registres écrits
!CRC
|-
| 1 octet
|10
|2 octets
| 2 octets
|2 octets
|}
 
'''<u>Exemple de Trame de Réponse</u>'''
 
Pour la trame de requête ci-dessus, la trame de réponse serait :
 
<code><big>01 10 00 10 00 02</big></code>
 
 
 
'''<u>Mise en œuvre sur ipx800</u>'''
 
[[Fichier:Modbus write RTU 10.png|sans_cadre|940x940px]]
 
La première analogique est valorisée à 10 (0A en hexa), la seconde à 11 (0B en hexa)


===== Requêtes de diagnostic=====
===== Requêtes de diagnostic=====
Diagnostic : 0x08
La fonction 8 en Modbus RTU, également connue sous le code 0x08, est utilisée pour '''diagnostiquer et tester''' les appareils esclaves.
Description : Effectuer des tests de diagnostic sur les esclaves.
 
====Logiciel Modbus====
Cette fonction permet au maître d’envoyer diverses commandes de diagnostic pour vérifier l’état et les performances de l’esclave.
 
Elle est non prise en charge par l'IPX800.
===Logiciel Modbus===
Pour lire les trames sur le bus RTU, vous pouvez utiliser divers logiciels gratuits disponibles sur le Web ([https://kscada.com/modbusdoctor.html Modbus Doctor], [https://fr.freedownloadmanager.org/Windows-PC/Simply-Modbus-Master.html Simply Modbus Master], [https://github.com/sanny32/OpenModScan Open ModScan], [https://www.automation-sense.com/blog/simulateur-modbus-modbus-plc-simulator.html ModRSsim])
Pour lire les trames sur le bus RTU, vous pouvez utiliser divers logiciels gratuits disponibles sur le Web ([https://kscada.com/modbusdoctor.html Modbus Doctor], [https://fr.freedownloadmanager.org/Windows-PC/Simply-Modbus-Master.html Simply Modbus Master], [https://github.com/sanny32/OpenModScan Open ModScan], [https://www.automation-sense.com/blog/simulateur-modbus-modbus-plc-simulator.html ModRSsim])


Ligne 214 : Ligne 822 :


Voilà, vous êtes prêt à communiquer en Modbus RTU entre votre PC (maître) et l'esclave.
Voilà, vous êtes prêt à communiquer en Modbus RTU entre votre PC (maître) et l'esclave.
=== Exemples d'utilisation===
 
====Capteur de conductivité Modbus RTU====
== Modbus TCP ==
 
=== Principe ===
Les trames Modbus TCP et Modbus RTU ne sont pas identiques, bien qu’elles partagent certaines similitudes en termes de structure de données.
 
Modbus TCP utilise la communication Ethernet et les trames Modbus sont encapsulées dans des paquets TCP/IP. Cela permet une communication plus rapide et plus flexible, avec la possibilité de gérer plusieurs connexions simultanées. Les trames TCP incluent un en-tête supplémentaire pour le protocole TCP/IP.
 
=== Mise en œuvre sur IPX800 ===
Pour émettre ou lire des trames, nous pouvons utiliser les objets "Modbus Write" et "Modbus Read".
 
Nous devrons alors activer le mode de communication TCP et préciser l'adresse IP de l'esclave.
 
Seul le paramétrage de l'entête change, la construction des données modbus avec les tuiles est identique.
 
En général, le port Modbus TCP est le 502. Dans nos exemples, nous utiliserons un port personnalisé 402.
 
 
 
'''<u>Objet Modbus Write</u>'''
 
[[Fichier:Image Modbus Write TCP.png|sans_cadre|835x835px]]
 
 
 
'''<u>Objet Modbus Read</u>'''
 
[[Fichier:Image Modbus TCP Read.png|sans_cadre|838x838px]]
 
==== Communication avec un équipement esclave : ====
L'esclave destinataire est déterminé par son adresse IP. La possibilité de saisir un ID a été ajoutée afin de pouvoir communiquer avec des esclaves RTU situés derrière une passerelle TCP<->RTU. Dans ce cas, l'adresse IP à renseigner est celle de la passerelle et l'ID celui de l'esclave à interroger.
 
<!--
==== Émission d'un message de diffusion : ====
En cas de message de diffusion (broadcast), il faut envoyer la requête sur une adresse IP de diffusion, vous devrez adapter cette adresse à votre réseau (192.168.1.255, 255.255.255.255, ...). L'ID doit être 0.
 
Exemple avec écriture d'un registre sur tous les dispositifs (e.g commande de réinitialisation) 
 
[[Fichier:Broadcast modbus tcp.png|sans_cadre|832x832px]]
 
Si vous avez une passerelle TCP<>RTU et que vous souhaitez diffuser vers les dispositifs RTU qui sont placés derrière, renseignez l''''ID 0''' (ID de diffusion) et l'adresse IP de la passerelle.
 
-->
 
==== Esclave RTU derrière une passerelle TCP <->RTU ====
[[Fichier:Modbus TCP -RTU.png|sans_cadre|827x827px]]
 
L'adresse IP correspond à la passerelle, l'ID au dispositif RTU à interroger.
== Exemples d'utilisation==
Le bus RS485 doit être réalisé avec des câbles blindés, avec blindage à la terre d'un côté.
 
[[Fichier:Image bus rs485 modbus.png|sans_cadre|1012x1012px]]
 
===Capteur de conductivité Modbus RTU===
J'ai acquis un capteur de conductivité (EC) qui me permettra de mesurer et réguler le taux de nutriments dans la solution qui nourrira le jardin hydroponique. Cette installation fera sans doute l'objet d'un autre article, mais je ne rentrerai pas dans les détails ici.
J'ai acquis un capteur de conductivité (EC) qui me permettra de mesurer et réguler le taux de nutriments dans la solution qui nourrira le jardin hydroponique. Cette installation fera sans doute l'objet d'un autre article, mais je ne rentrerai pas dans les détails ici.


Ligne 222 : Ligne 882 :
Chaque grandeur pourra alors être demandée par le maître.
Chaque grandeur pourra alors être demandée par le maître.


===== Branchement sur l'adaptateur USB=====
==== Branchement sur l'adaptateur USB====
[[Fichier:Capteur EC RS485 en USB.png|sans_cadre|1001x1001px]]
[[Fichier:Capteur EC RS485 en USB.png|sans_cadre|1001x1001px]]


=====Les premiers tests de communication =====
====Les premiers tests de communication ====
À partir de la documentation du produit, nous pouvons configurer les communications, exploiter les réponses sur le bus, ...  
À partir de la documentation du produit, nous pouvons configurer les communications, exploiter les réponses sur le bus, ...  


je vous épargne les pages en mandarin qui accompagnaient mon capteur. Heureusement, Google Lens permet des traductions instantanées à partir de documents au format image.
je vous épargne les pages en mandarin qui accompagnaient mon capteur. Heureusement, Google Lens permet des traductions instantanées à partir de documents au format image.


======Configuration du port======
=====Configuration du port=====
Pour communiquer avec le produit, il faut d'abord configurer le port COM via le logiciel que vous aurez choisi.
Pour communiquer avec le produit, il faut d'abord configurer le port COM via le logiciel que vous aurez choisi.


Ligne 252 : Ligne 912 :
[[Fichier:Modbus doctor config.png|sans_cadre|661x661px]]
[[Fichier:Modbus doctor config.png|sans_cadre|661x661px]]


======Liste des registres accessibles======
=====Liste des registres accessibles=====
La documentation doit impérativement lister les adresses et formats des données pour que vous puissiez exploiter votre appareil.
La documentation doit impérativement lister les adresses et formats des données pour que vous puissiez exploiter votre appareil.
{| class="wikitable"
{| class="wikitable"
Ligne 260 : Ligne 920 :
!Plage
!Plage
!Lecture/Ecriture
!Lecture/Ecriture
!Fonction supportées
!Fonctions supportées
|-
|-
|0x 00 00
|0x 00 00
Ligne 293 : Ligne 953 :
Le matériel Made in China est donc d'un rapport qualité/prix excellent, mais il faut très souvent s'attendre à galérer un peu pour la mise en œuvre.
Le matériel Made in China est donc d'un rapport qualité/prix excellent, mais il faut très souvent s'attendre à galérer un peu pour la mise en œuvre.


======Format d'une requête "Lecture" de registre======
=====Format d'une requête "Lecture" de registre=====
Le format de la requête émise par le maître est standardisé, la trame  est donc toujours construite de la même façon.
La réponse émise par l'esclave lors de la réception de cette requête est également formatée, mais en partie seulement. En effet, le champ "Données" n'a pas de format imposé. Le fabricant peut alors adapter le message à son produit.
 
{| class="wikitable"
! Adresse de l'esclave
!code fonction
!Adresse 1er  registre
(bit fort)
! Adresse 1er registre
(bits faibles )
!Nombre de registres à lire
(bits forts)
! nombre de registres à lire
(bits faibles)
!CRC
(bits forts)
!CRC
(bits faibles)
|-
| 1 octet
|03
|1 octet
|1 octet
|1 octet
|1 octet
| 1 octet
|1 octet
|}
La réponse émise par l'esclave lors de la réception de cette requête est également formatée, mais en partie seulement. En effet, le champ "Données" n'a pas de format imposé. Le fabricant peut alors adapter le message à son produit.  


Le fabricant doit alors documenter la construction de trame adoptée, le format de chaque registre et son adresse, afin que l'utilisateur final puisse lire et convertir ces variables en grandeurs réelles.
Le fabricant doit alors documenter la construction de trame adoptée, le format de chaque registre et son adresse, afin que l'utilisateur final puisse lire et convertir ces variables en grandeurs réelles.
Ligne 341 : Ligne 974 :
Nous pouvons constater que les données du capteur sont constituées de paires d'octets, dont le nombre dépend de la requête d'interrogation reçue.
Nous pouvons constater que les données du capteur sont constituées de paires d'octets, dont le nombre dépend de la requête d'interrogation reçue.


======Lecture de la valeur de conductivité======
=====Lecture de la valeur de conductivité=====


* '''émission de la requête du maître vers l'esclave :'''  Selon la documentations ci-dessus, construisons la requête de type 03 à destination de l'esclave #1 pour récupérer la valeur de la conductivité avec notre logiciel.  Réglez le logiciel pour un affichage en hexadécimal.
* '''émission de la requête du maître vers l'esclave :'''  Selon les standards de la fonction 03, construisons la requête de type 03 à destination de l'esclave #1 pour récupérer la valeur de la conductivité avec notre logiciel.  Réglez le logiciel pour un affichage en hexadécimal.


{|
{|
Ligne 405 : Ligne 1 038 :
Nous obtenons après conversion hexadécimale vers décimal : 6*256 + 250 = 1786 µS/cm
Nous obtenons après conversion hexadécimale vers décimal : 6*256 + 250 = 1786 µS/cm


======Lecture de la température======
=====Lecture de la température=====


* '''émission de la requête du maître vers l'esclave :'''
* '''émission de la requête du maître vers l'esclave :'''
Ligne 462 : Ligne 1 095 :
Si nous appliquons la formule donnée par la documentation, la température est  ((0x00 * 256) + 0xC6 )/10 soit 19.8°C
Si nous appliquons la formule donnée par la documentation, la température est  ((0x00 * 256) + 0xC6 )/10 soit 19.8°C


====== Requête "Écriture" de registre======
===== Requête "Écriture" de registre=====
Comme pour les requêtes de lecture, le format de la demande d'écriture est toujours construit de la même façon.
Pour rappel de format de la requête est standardisé. Voir plus haut.
 
{| class="wikitable"
!Adresse de l'esclave
!code fonction
!Bit fort adresse registre
!Bit faible adresse registre
!valeur à écrire dans le registre
(bits forts)
!valeur à écrire dans le registre
(bits faibles)
!CRC (bits forts)
!CRC (bits faibles)
|-
|1 octet
|06H
|1 octet
|1 octet
|1 octet
|1 octet
|1 octet
|1 octet
|}
 
* Émission de la requête Émettons la requête suivante qui permet de modifier l'ID à 2.
* Émission de la requête Émettons la requête suivante qui permet de modifier l'ID à 2.
{|
{|
Ligne 512 : Ligne 1 122 :
A faire :'''Vérifier si réponse de l'esclave. commenter ici.'''
A faire :'''Vérifier si réponse de l'esclave. commenter ici.'''


===== Capteur EC sur IPX800 V5 =====
==== Capteur EC sur IPX800 V5 ====


====== Le schéma de connexion ======
===== Le schéma de connexion =====
L’IPX800 V5 propose des objets “Modbus Read” pour les requêtes de lecture et des objets “Modbus Write” pour les fonctions d’écriture sur les registres.
L’IPX800 V5 propose des objets “Modbus Read” pour les requêtes de lecture et des objets “Modbus Write” pour les fonctions d’écriture sur les registres.


Ligne 523 : Ligne 1 133 :
[[Fichier:Connexion EC RTU v5.png|sans_cadre|808x808px]]
[[Fichier:Connexion EC RTU v5.png|sans_cadre|808x808px]]


====== Configuration du mode de communication ======
===== Configuration du mode de communication =====
La configuration du mode de communication série (RTU)  se fait de manière centrale sur la page SYSTEM via la tuile MODBUS.
La configuration du mode de communication série (RTU)  se fait de manière centrale sur la page SYSTEM via la tuile MODBUS.


Ligne 532 : Ligne 1 142 :
[[Fichier:Image config COM RTU.png|sans_cadre]]
[[Fichier:Image config COM RTU.png|sans_cadre]]


====== Création d'un objet Lecture ======
===== Création d'un objet Lecture =====
La création d'un objet "Modbus read" nécessite la connaissance du format de la trame RTU.
La création d'un objet "Modbus read" nécessite la connaissance du format de la trame RTU.


Ligne 543 : Ligne 1 153 :
La réponse de l'esclave contient les données sur 2 octets comme nous avons pu le tester précédemment.  
La réponse de l'esclave contient les données sur 2 octets comme nous avons pu le tester précédemment.  


Vu que nous devons appliquer une formule sur chacun d'eux pour obtenir notre température, nous devons utiliser 2 analogiques 8 bits plutôt qu'une seule analogique 16 bits
Nous pourrions récupérer ces 2 octets dans une variable 16 bits mais pour l'exemple  nous allons utiliser 2 analogiques 8 bits.


Lorsque l'on dépose une tuile, il est immédiatement demandé d'associer une ressource (source de données).
Lorsque l'on dépose une tuile, il est immédiatement demandé d'associer une ressource (source de données).
Ligne 557 : Ligne 1 167 :
L'ipx800 affiche les valeurs en décimal.
L'ipx800 affiche les valeurs en décimal.


====== Création d'un objet Écriture ======
===== Création d'un objet Écriture =====
Notre capteur accepte les requêtes Écriture sur le registre en adresse 3, ce qui permet l'affectation d'un ID unique.
Notre capteur accepte les requêtes Écriture sur le registre en adresse 3, ce qui permet l'affectation d'un ID unique.


Ligne 568 : Ligne 1 178 :
Vous pouvez tester la requête avec le bouton d'envoi.
Vous pouvez tester la requête avec le bouton d'envoi.


====== Exemple d'utilisation ======
===== Exemple d'utilisation =====
Notre capteur ne nécessite pas l'automatisation des requêtes d'écriture. En effet, seul le changement d'ID est possible, et celui-ci ne se fait qu'une fois en théorie, à la mise en œuvre du dispositif.
Notre capteur ne nécessite pas l'automatisation des requêtes d'écriture. En effet, seul le changement d'ID est possible, et celui-ci ne se fait qu'une fois en théorie, à la mise en œuvre du dispositif.


Ligne 585 : Ligne 1 195 :
Il ne reste plus qu'à créer un objet fonction qui calculera la grandeur réelle via la formule communiquée par le fabricant.
Il ne reste plus qu'à créer un objet fonction qui calculera la grandeur réelle via la formule communiquée par le fabricant.


Il suffit alors de créer une formule utilisant les variables sous la forme $id$.
Comme je l'ai écrit plus haut, j'ai utilisé volontairement 2 variables de 8 bits afin de vous montrer une utilisation avancée des objets fonctions : les variables.
 
Nous allons donc créer une formule utilisant les variables sous la forme $id$.
 




Ligne 596 : Ligne 1 209 :


puis j'ai lié la variable représentant l'octet de poids faible à cet objet. Sa formule reprend le résultat de la fonction précédente pour l'obtention du résultat final.
puis j'ai lié la variable représentant l'octet de poids faible à cet objet. Sa formule reprend le résultat de la fonction précédente pour l'obtention du résultat final.
Pour plus d'informations concernant l'usage des variables dans les formules, veuillez vous référer à [https://wiki.gce-electronics.com/index.php?title=Utilisation_des_variables cet article].


[[Fichier:Image fonction 2 temp rtu.png|sans_cadre|566x566px]]
[[Fichier:Image fonction 2 temp rtu.png|sans_cadre|566x566px]]
Ligne 603 : Ligne 1 218 :
La  formule diffère un peu vu que je corrige la valeur EC selon la température. Je n'entrerai pas dans les détails ici.
La  formule diffère un peu vu que je corrige la valeur EC selon la température. Je n'entrerai pas dans les détails ici.


==== Capteur de dioxyde de carbone ====
Remarque : si nous avions glissé une tuile analogique 16 bits dans l'objet Modbus Read au lieu des 2 tuiles 8 bits, la formule de l'objet fonction serait plus simple et deviendrait  X/10.
Cela n'imposerait pas le découpage de la formule sur 2 fonctions.
 
=== Capteur de dioxyde de carbone ===
 
==== Connexion à l'IPX800 ====
[[Fichier:Image CO2 RTU.png|sans_cadre|770x770px]]
 
==== Adresses des données ====
Ces informations sont communiquées par le fabricant.
{| class="wikitable"
|+Registres de données
!Adresse de registre
(Hex)
!nom du registre
!Nombre d'octets
!Contenu
!Fonction supportée
|-
|0000
|Humidité
|2
|0.1%RH
|Lecture
|-
|0001
|Température
|2
|0.1°C
|Lecture
|-
|0002
|CO2
|2
|1 ppm
|Lecture
|-
|0033
|Valeur de calibration température
|2
|0.1
|Lecture/écriture
|-
|0038
|Valeur de calibration Humidité
|2
|0.1
|Lecture/écriture
|-
|003D
|Valeur de calibration CO2
|2
|1  ppm
|Lecture/écriture
|}
{| class="wikitable"
|+Registres de configuration
!Adresse de registre
(Hex)
!nom du registre
!Nombre d'octets
!Contenu
!Fonction supportée
|-
|07D0
|ID esclave
|2
|1-254
|Lecture/écriture
|-
|07D1
|Baud Rate
|2
|0:2400
1:4800*
 
2:9600
|Lecture/écriture
|-
|
|
|
|
|
|}
 
===== requêtes de lecture =====
Nous avons pu voir plus haut avec le capteur de conductivité que le format des requêtes est standardisé.
 
Nous appliquerons donc le même standard ici.
 
===== Exemple 1 : l'humidité =====
L'adresse du registre contenant la valeur du taux d'humidité est 00 00. Nous souhaitons lire 1 registre.
 
L'ID du capteur est 1.
 
Constituons la requête avec la fonction 03
 
01 : ID
 
03 : Fonction de lecture
 
00 00 : adresse du 1er registre à lire sur 2 octets
 
00 01 :  nombre de registres consécutifs à lire (2 octets)
 
xx xx : CRC code calculé par le logiciel
 
{|
!'''<big>01</big>'''
!<big>03</big>
!<big>00</big>
!<big>00</big>
!<big>00</big>
!<big>01</big>
!xx
!xx
|}
 
Le capteur répond avec cette trame :
 
{|
!'''<big>01</big>'''
!<big>03</big>
!<big>02</big>
!<big>00</big>
!<big>D5</big>
!<big>79</big>
!<big>DB</big>
|}
 
01 : ID
 
03 : Fonction de lecture
 
02 : nombre d'octets constituant la réponse
 
00 D5 : valeur de l'humidité
 
79 DB : CRC
 
La valeur d'humidité est donc ((00 * 256) + 213)/10 = 21.3%RH
 
===== Exemple 2 : le CO2 =====
L'adresse du registre pour le CO2 est 00 02.
 
{|
!'''<big>01</big>'''
!<big>03</big>
!<big>00</big>
!<big>02</big>
!<big>00</big>
!<big>01</big>
!xx
!xx
|}
 
01 : ID
 
03 : Fonction lecture
 
00 02 : adresse 1er registre à lire
 
00 01 : nombre de registres à lire
 
xx xx : CRC
 
Le capteur envoie cette réponse
 
{|
!'''<big>01</big>'''
!<big>03</big>
!<big>02</big>
!<big>0B</big>
!<big>B8</big>
!<big>BF</big>
!<big>06</big>
|}
 
01 : ID
 
03 : Fonction de lecture
 
02 : nombre d'octets constituant la réponse
 
0B B8 : valeur de l'humidité
 
BF 06 : CRC
 
La quantité de CO2 est donc ((11* 256) + 184) = 3000 ppm
 
===== Exemple 3 : humidité, température et CO2 ensemble =====
L'adresse du premier registre à lire est 00 00
 
{|
!'''<big>01</big>'''
!<big>03</big>
!<big>00</big>
!<big>00</big>
!<big>00</big>
!03
!<big>xx</big>
!<big>xx</big>
|}
 
01 : ID
 
03 : Fonction lecture
 
00 00 : adresse 1er registre à lire
 
00 03 : nombre de registres à lire
 
xx xx : CRC
 
Le capteur envoie cette réponse
 
{|
!'''<big>01</big>'''
!<big>03</big>
!<big>06</big>
!<big>01</big>
!<big>67</big>
!<big>FF</big>
!<big>85</big>
!<big>0B</big>
!<big>B8</big>
!<big>33</big>
!<big>DC</big>
|}
 
01 : ID
 
03 : Fonction lecture
 
06 : nombre d'octets dans les données
 
01 67 : valeur d'humidité. L'humidité est de 359/10=35.9 %RH
 
FF 85 : valeur de température. Quand elle est négative, elle remonte comme complément. Ici, la température vaut -7.5°C
 
0B B8 : Valeur CO2. Le CO2 est de 3000 ppm
 
33 BC : CRC
 
==== Requêtes d'écriture ====
Appliquons les standards aux requêtes d'écriture
 
===== Exemple 1 : modification de l'ID =====
Nous souhaitons modifier l'ID 01 en ID 02. Nous émettons une requête type 06
 
T'''<u>rame émise</u>'''
 
{|
!'''<big>01</big>'''
!<big>06</big>
!<big>07</big>
!<big>D0</big>
!<big>00</big>
!<big>02</big>
!<big>08</big>
!<big>86</big>
|}
 
01 : id esclave
 
06 : Fonction écriture d'un registre de maintien unique
 
07 D0 : adresse du registre à modifier
 
00 02 : donnée à écrire (nouvel ID)
 
08 86 : CRC
 
 
'''<u>Réponse de l'esclave</u>'''
 
{|
!'''<big>01</big>'''
!<big>06</big>
!<big>07</big>
!<big>D0</big>
!<big>00</big>
!<big>02</big>
!<big>08</big>
!<big>86</big>
|}
 
L'esclave réémet la même trame pour confirmer le traitement.
 
=====  Exemple 2 : modification du Baud Rate =====
Par défaut, le capteur est configuré en 4800 Bauds. Nous souhaitons le passer en 9600 Bauds.
 
T'''<u>rame émise</u>'''
 
{|
!'''<big>01</big>'''
!<big>06</big>
!<big>07</big>
!<big>D1</big>
!<big>00</big>
!<big>02</big>
!<big>59</big>
!<big>46</big>
|}
 
01 : id esclave
 
06 : Fonction écriture d'un registre de maintien unique
 
07 D1 : adresse du registre à modifier
 
00 02 : donnée à écrire . La valeur 2 correspond à 9600 Bauds selon la documentation.
 
59 46 : CRC
 
 
'''<u>Réponse de l'esclave</u>'''
 
{|
!'''<big>01</big>'''
!<big>06</big>
!<big>07</big>
!<big>D1</big>
!<big>00</big>
!<big>02</big>
!<big>59</big>
!<big>46</big>
|}
 
L'esclave réémet la même trame pour confirmer le traitement.
 
== Astuces ==
 
=== Le complément à 2 ===
Au moment de la rédaction de cet article, l'IPX800 V5 ne reconnait ni ne traite les valeurs négatives envoyées par les capteurs RTU.  En effet, la plupart d'entre eux émet la valeur en appliquant le complément à 2 qui est une méthode utilisée en informatique pour représenter les nombres entiers, en particulier les nombres négatifs, en binaire. Voici comment cela fonctionne :
# '''Inversion des bits''' : Pour trouver le complément à 2 d’un nombre binaire, commencez par inverser tous les bits du nombre (changez les 0 en 1 et les 1 en 0). Par exemple, pour le nombre binaire <code>0101</code>, l’inversion des bits donne <code>1010</code>.
# '''Ajout de 1''' : Ensuite, ajoutez 1 au nombre inversé. En continuant avec notre exemple, <code>1010</code> devient <code>1011</code> après l’ajout de 1.
'''Exemple''' : La température est de -7.5°C, vu que la valeur est négative, le capteur doit émettre le complément à 2 de 75.
 
Inversion des bits : 75 en binaire sur 2 octets s'écrit est 00000000 01001011.
 
L'inversion des bits donne 11111111 10110100
 
Ajout de 1 : le résultat est de 11111111 10110101, soit FF B5 en hexadécimal.
 
 
 
Pour contourner ce manque, @GwenLR propose une solution construite avec un comparateur et un objet fonction.
 
=> Si la valeur reçue de Modbus est inférieure à 32768, elle est réputée positive. La sortie du comparateur passe ON. Sa valeur est donc 1. L'objet formule traite alors cette valeur normalement avec un gain de 0.1 pour le traitement des décimales.
 
La formule est en effet équivalente à '''''X/10'''''.
 
=> Si la valeur reçue de Modbus est supérieure à 32768, la sortie du comparateur passe à OFF. La valeur reçue est réputée négative car le capteur l'a transmise avec l'application du complément à 2. Pour détricoter cela, il faut alors retrancher 65536 de la valeur lue. Cette opération est faite grâce au passage à ON de l'IO (donc valorisée à 1) liée par un lien de type NOT à la sortie du comparateur. La formule de l'objet fonction devient alors équivalente à '''''(X - 65536)/10'''''.
 
[[Fichier:Complément à 2 Modbus.png|sans_cadre|1110x1110px]]
 
Vous pouvez vous référer à [https://forum.gce-electronics.com/t/modbus-tcp-gestion-valeur-negative/17855/19?u=fgtoul ce post sur le forum] pour plus d'information.
 
== Interception et analyse de trames Modbus ==
Précédemment nous avons vu comment simuler un maître ou un esclave Modbus grâce à des logiciels gratuits comme Modbus Doctor.
 
Pour analyser les échanges entre l'IPX800 V5 et ses esclaves Modbus, il est également possible de connecter un PC sur le bus et d'utiliser un logiciel de capture de trames, à des fins d'analyse.
 
En RTU, vous devrez utiliser un adaptateur USB-RS485, en TCP/IP il suffira de mettre le PC sur le même réseau que l'IPX800.
 
=== Modbus RTU ===
 
# '''Utiliser un analyseur de protocole''' : Un analyseur de protocole Modbus RTU, tel que Wireshark avec un plugin Modbus, peut être utilisé pour capturer et analyser les trames. Vous aurez besoin d’un convertisseur RS-485 vers USB pour connecter le réseau Modbus à votre ordinateur.
# '''Utiliser un enregistreur de données''' : Un enregistreur de données Modbus peut être placé sur le réseau pour capturer les trames de communication. Ces enregistreurs peuvent stocker les données pour une analyse ultérieure.
#* '''Simply Modbus Slave''' : Ce logiciel permet de tester et de déboguer les systèmes Modbus RTU et ASCII. Il affiche également le trafic de données et ne nécessite aucune installation.
#* '''Modbus Poll''' : Bien que ce logiciel soit principalement payant, il offre une version d’essai gratuite qui peut être utile pour des besoins temporaires ou pour évaluer ses fonctionnalités.
#* '''QModMaster''' : Un logiciel open-source qui permet de tester et de déboguer les communications Modbus RTU et TCP. Il est disponible gratuitement et offre une interface utilisateur conviviale.
# '''Utiliser un logiciel de supervision''' : Certains logiciels de supervision et de contrôle (SCADA) offrent des fonctionnalités de capture et d’analyse des trames Modbus RTU. Vous pouvez configurer le logiciel pour enregistrer les communications entre le maître et les esclaves.
#* '''QModMaster''' : Un logiciel open-source qui permet de tester et de déboguer les communications Modbus RTU et TCP. Il est disponible gratuitement et offre une interface utilisateur conviviale1.
#* '''Modbus Doctor''' : Un utilitaire freeware permettant de se connecter aux appareils industriels communiquant en protocole Modbus RTU ou TCP. Ce logiciel permet de tester et mettre au point une liaison Modbus de manière visuelle et conviviale2.
#* '''Simply Modbus Slave''' : Ce logiciel permet de tester et de déboguer les systèmes Modbus RTU et ASCII. Il affiche également le trafic de données et ne nécessite aucune installation
# '''Utiliser un microcontrôleur''' : Vous pouvez programmer un microcontrôleur (comme un Arduino ou un ESP32) pour écouter les communications sur le bus Modbus et enregistrer les trames pour une analyse ultérieur Voici quelques bibliothèques pour ESP32:
#* '''ESP-Modbus''' : Une bibliothèque officielle d’Espressif pour la communication Modbus sur les réseaux basés sur RS485, WiFi et Ethernet. Elle prend en charge les implémentations maître et esclave pour les ports série et TCP1.
#* '''Modbus-ESP''' : Une bibliothèque qui permet à votre ESP8266/ESP32 de communiquer via le protocole Modbus, en agissant comme maître, esclave ou les deux. Elle prend en charge Modbus IP via réseau sans fil et Modbus RTU via ligne série2.
#* '''eModbus''' : Une bibliothèque Modbus pour les protocoles RTU, ASCII et TCP, principalement développée pour les microcontrôleurs ESP323.
# '''Utiliser un convertisseur RS-485''' : Connectez un convertisseur RS-485 à votre ordinateur et utilisez un logiciel de terminal série pour capturer les trames Modbus RTU. Vous pouvez ensuite analyser les données capturées manuellement ou avec un logiciel d’analyse.
#*'''PuTTY, Tera Term, ou RealTerm'''
#*[https://www.serial-port-monitor.org/fr/ '''Serial port Monitor''']
 
=== Modbus TCP ===
Pour intercepter et analyser des trames Modbus TCP, vous pouvez suivre ces étapes :
 
# '''Utiliser Wireshark''' : Wireshark est un outil puissant pour capturer et analyser les trames réseau, y compris Modbus TCP. Vous pouvez installer Wireshark sur votre ordinateur et configurer une capture de paquets sur l’interface réseau utilisée par le Modbus TCP. Wireshark dispose de filtres spécifiques pour Modbus qui facilitent l’analyse des trames.
# '''Utiliser un analyseur de protocole Modbus''' : Il existe des logiciels spécialisés pour l’analyse des trames Modbus TCP. Ces outils peuvent fournir des informations détaillées sur les communications Modbus et aider à diagnostiquer les problèmes.
# '''Configurer un port mirroring''' : Si vous utilisez un switch manageable, vous pouvez configurer le port mirroring pour copier le trafic réseau de l’interface Modbus TCP vers une autre interface où vous pouvez capturer les trames avec Wireshark ou un autre outil d’analyse.
# '''Utiliser un logiciel de supervision''' : Certains logiciels de supervision et de contrôle (SCADA) offrent des fonctionnalités de capture et d’analyse des trames Modbus TCP. Vous pouvez configurer le logiciel pour enregistrer les communications entre le maître et les esclaves.
 
Pour plus de détails, vous pouvez consulter des tutoriels vidéo [https://www.youtube.com/watch?v=rGYzGPdJpOs comme celui-ci sur YouTube] qui explique comment analyser les trames Modbus TCP avec Wireshark


== Conclusion ==
== Conclusion ==
Ligne 612 : Ligne 1 621 :
Pour ma part, je peux désormais envisager mon futur projet : un système de dosage automatique des engrais liquides dans la solution nutritive d’un mini potager hydroponique, avec régulation du taux de CO<sub>2</sub> pour la santé des plants.
Pour ma part, je peux désormais envisager mon futur projet : un système de dosage automatique des engrais liquides dans la solution nutritive d’un mini potager hydroponique, avec régulation du taux de CO<sub>2</sub> pour la santé des plants.


[[Fichier:Image potager hydroponique.png|vignette|496x496px]]Amis débutants, j’espère que cet article vous aura permis de découvrir et mieux comprendre le protocole Modbus, peut-être en aurez vous besoin au sein de votre installation. Même si nous n’avons pas abordé des sujets complexes comme  la gestion d’appareils technologiques sophistiqués tels que les climatiseurs gainables, ne vous découragez pas !
[[Fichier:Image potager hydroponique.png|vignette|496x496px]]Amis débutants, j’espère que cet article vous aura permis de découvrir ou approfondir le protocole Modbus, peut-être en aurez vous besoin au sein de votre installation. Même si nous n’avons pas abordé des sujets complexes comme  la gestion d’appareils technologiques sophistiqués (e.g : climatiseurs gainablesne vous découragez pas !


Modbus étant open-source, il existe d'innombrables bibliothèques prêtes à l'emploi permettant aux non-initiés de concevoir leurs propres appareils communicants à base  de SBC (ESP8266, ESP32, RPI, ...).
Modbus étant open-source, il existe d'innombrables bibliothèques prêtes à l'emploi permettant aux non-initiés de concevoir leurs propres appareils communicants à base  de SBC (ESP8266, ESP32, RPI, etc.).


La communauté du forum regorge d’experts en Modbus qui seront ravis de vous guider dans les cas plus complexes. N’hésitez pas à poser vos questions et à partager vos expériences !
Des spécialistes Modbus sont présents parmi la communauté du forum, ils seront ravis de vous guider dans les cas plus complexes. N’hésitez pas à poser vos questions et à partager vos expériences !


== Annexes : ==
== Annexes ==
[https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf Modbus Specifications]
[https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf Modbus Specifications]

Version actuelle datée du 13 octobre 2024 à 05:42

Modbus

Modbus-dall-e.jpg
Nom Modbus
Famille IPX800 V5
Wiki créé le 11/09/2024
Wiki mis à jour le 21/09/2024
Auteur fgtoul

Introduction

Nous allons explorer un sujet technique qui pourrait sembler intimidant pour certains. J'étais dans le même bateau, jusqu'à ce qu'un chevalier blanc m'explique les bases ! Merci @Jweb !

Aujourd'hui, je ne prétends pas être un expert en la matière, mais je souhaite partager ce que j'ai appris pour vous aider à l'intégration de ces appareils dans votre installation sans vous laisser décourager par le protocole Modbus.

Ce qui va suivre n'est pas un guide exhaustif sur le protocole Modbus, mais plutôt une explication simplifiée adaptée à nos configurations utilisant les IPX800 V5.

Historique

Modicon, une entreprise américaine, a introduit le protocole Modbus il y a 45 ans pour permettre aux automates programmables et aux dispositifs industriels de communiquer entre eux. En 1996, Schneider Electric a racheté Modicon. Sous la marque Modicon, l’entreprise française a développé et commercialisé une large gamme de contrôleurs et de solutions utilisant Modbus.

En 2004, Schneider Electric a transféré les droits à l’organisation [Modbus.org]. Depuis lors, les spécifications sont disponibles gratuitement et il n’y a pas de frais de licence pour l’utilisation des protocoles Modbus et Modbus TCP.

À l’origine, Modbus permettait les communications sur un bus filaire série. Cependant, les contraintes de ce mode de communication ont conduit à des évolutions telles que Modbus TCP, qui permet des communications sur des distances beaucoup plus longues et avec un nombre de périphériques théoriquement illimité.


Les commandes disponibles ont été définies selon les besoins du moment. Elles sont restées identiques à ce jour.

Nous retrouverons donc 4 grandes familles :

  • Les entrées discrètes (discrete inputs) : Ce sont des entrées tout ou rien (TOR) comme des boutons, capteurs,, représentées par une valeur booléenne.En Modbus Il est possible de traiter jusqu'à 2000 valeurs en 1 seule commande, l'IPX800 imposera ses propres limitations. Accessibles en lecture seule.
  • Les bobines (coils) : ce sont les sorties TOR. Nous les utiliserons pour piloter des relais, contacteurs, .... Elles sont représentées par des valeurs booléennes. Le protocole stipule qu'Il est possible de traiter jusqu'à 2000 valeurs en une seule commande, l'IPX800 imposera ses propres limitations. Accessibles en lecture écriture.
  • Les registres d'entrées : ce sont des zones mémoire permettant la saisie de valeurs numériques représentées par des mots de 16 bits. Il est possible de traiter jusqu'à 125 registres en une seule commande, l'IPX800 imposera ses propres limitations. Accessibles en lecture seule.
  • Les registres de maintien : zones mémoire pour mémoriser ou ressortir des valeurs numériques représentées par des mots de 16 bits. Il est possible de traiter jusqu'à 125 registres en une seule commande, l'IPX800 imposera ses propres limitations .Accessibles en lecture/écriture.

RTU vs TCP

Modbus RTU

Modbus RTU (Remote Terminal Unit) : Utilise une communication série (RS232, RS485) avec une transmission binaire compacte. C’est le mode le plus couramment utilisé dans les environnements industriels.

RS232 est sensible aux parasitages, ne permet que de courtes distances. Il est également très limité en nombre d'esclaves.

La communication Modbus sur notre IPX800 utilise l'interface RS485 en architecture maître/esclave, avec 1 seul maître sur le réseau (dans notre cas l'IPX étant le maître).

Dans ce système, le maître prend l'initiative et interroge les esclaves, qui attendent les requêtes du maître pour fournir des informations. Les dispositifs esclaves ne peuvent pas envoyer de données de manière autonome.

Le maître a la possibilité d'écrire ou de lire des données dans les registres des périphériques esclaves.

Modbus RTU sur RS485 fonctionne généralement en mode half-duplex, ce qui signifie que les données peuvent être envoyées dans les deux sens, mais pas simultanément. Dans ce cas, le bus utilise 2 fils au lieu de quatre.


Avantages :

Simplicité : Facile à implémenter et à configurer.

Coût : Moins coûteux en termes de matériel et de mise en œuvre.

Fiabilité : Utilise une communication série (RS485), qui est robuste et fiable pour les environnements industriels.

Efficacité : Optimise l’utilisation de la bande passante grâce à une transmission binaire compacte.


Inconvénients :

Distance limitée : La distance maximale sans répéteur est d’environ 1200 mètres.

Nombre limité d’appareils : Peut connecter jusqu’à 32 appareils sur une seule ligne sans répéteur (247 avec répéteurs).

Débit de données : Plus lent par rapport à Modbus TCP, avec des taux de transfert de données limités par la vitesse de la communication série (9600 ou 115200 Bauds)

1 seul maître sur le réseau, ce qui interdit la communication avec certains appareils comme des onduleurs photovoltaïques souvent maîtres eux-mêmes.



Modbus TCP/IP

Modbus TCP/IP fonctionne sur des réseaux Ethernet, permettant une communication plus rapide et une intégration facile avec les réseaux informatiques existants.

Plusieurs maîtres peuvent communiquer sur un même réseau.

Cette architecture Maîtres/Esclaves fonctionne en mode full-duplex, permettant l’envoi et la réception de données simultanément dans les deux sens. Cela améliore la vitesse et l’efficacité de la communication.


Avantages :

Vitesse : Offre des taux de transfert de données plus rapides grâce à l’utilisation des réseaux Ethernet.

Scalabilité : Peut gérer un nombre théoriquement illimité d’appareils sur un réseau IP.

Flexibilité : Permet des connexions filaires et sans fil, facilitant l’intégration avec les infrastructures réseau existantes.

Installation facile : Utilise du matériel Ethernet standard, ce qui simplifie l’installation et la configuration.


Inconvénients :

Coût : Plus coûteux en termes de matériel et de mise en œuvre par rapport à Modbus RTU.

Latence : Peut avoir une latence plus élevée en raison de la surcharge du protocole TCP/IP4.

Complexité : Plus complexe à configurer et à maintenir, nécessitant une connaissance des réseaux IP4.

Conclusion

Modbus RTU est idéal pour les systèmes plus petits et moins complexes où la simplicité et le coût sont des facteurs importants.

Modbus TCP est mieux adapté aux systèmes plus grands et plus complexes nécessitant une communication rapide et une grande scalabilité.

Modbus RTU

Le maître

Notre IPX800 V5 possède tous les outils pour interroger ou piloter des dispositifs sur son réseau Modbus.

L'IPX800 peut envoyer des requêtes de lecture ou d'écriture de données vers un dispositif particulier grâce à l'adresse unique qui identifie chaque esclave (1 à 247). L'esclave répond à la requête.

RTU requête simple.png

Il peut également s'adresser à tous les esclaves simultanément en envoyant un message de diffusion (Broadcast) sur l'adresse 0 ou 254. Les esclaves ne répondent pas.

Vu que tous les esclaves ne peuvent pas répondre simultanément, le broadcast est utilisé pour l'envoi de commandes d'écriture.

Image broadcast RTU.png

NB : L'IPX800 est maître et doit être le seul maître sur le bus série.

L'esclave

Chaque esclave est identifié par son adresse réseau unique(ID). L'esclave, comme nous l'avons abordé plus haut, ne peut prendre aucune initiative. Il reste en veille jusqu'à réception d'une requête émise par le maître. Si la requête lui est bien adressée (son adresse réseau unique correspond), il traite la demande et renvoie une réponse au maître. Il traitera également toute demande envoyée sous forme de Broadcast.


Certains esclaves modbus RTU comportent 2 ports série distincts leur permettant alors de communiquer avec 2 maîtres, sans que les bus RS485 ne soient fusionnés.

Image esclave rtu 2 ports.png

Mise en œuvre sur IPX800 V5

L'ipx800 V5 dispose de 2 objets permettant d'émettre ou recevoir des trames Modbus RTU. Nous verrons l'utilisation de ces objets dans le paragraphe suivant.

Objet Modbus read

Cet objet permet de traiter les fonction 1,2,3 et 4. Il est possible de lire jusqu'à 48 octets.

Image modbus read 00.png

La construction de la structure du champ de données est faite à partir de tuiles IO ou analoqiques qui sont déposées dans le conteneur drag&drop Image drag-drop.png.

Ces mêmes tuiles définissent alors les variables qui seront utilisées pour stocker les valeurs contenues dans la réponse de l'esclave.

Vous pourrez alors utiliser ces variables dans vos règles et liens.

Objet Modbus Write

Cet objet permet de traiter les requêtes 5, 6, 15 et 16.

Image modbus write 00.png

La construction des données à écrire se fait à partir des tuiles IO et analogiques que vous déposez dans le conteneur drag&drop Image drag-drop.png.

Vous devez alors prévoir de valoriser chaque variable avant l'envoi de la requête. Cette valorisation peut se faire par règle ou lien, comme n'importe quelle ressource.

Les requêtes

En Modbus, les messages sont encapsulés dans un format binaire compact et transmis via des interfaces série (RS485 pour notre IPX).

Chaque message contient une adresse d’esclave, un code de fonction, des données et un CRC (Cyclic Redundancy Check) pour la vérification des erreurs.


Chaque octet de la trame Modbus est codé sur 2 caractères hexadécimaux. La trame sera composée de 256 octets maximum.

Silence Adresse Fonction Données CRC Silence
Début 1 octet 1 octet n octets 2 octets Fin
0 à 247 1 à 127 Données à envoyer Contrôle

Pour connaître les requêtes utilisables sur votre appareil esclave, vous devrez vous référer à la documentation du fabricant.

L'adressage : 
A l'origine, la mémoire était organisée par catégorie de matériel pilotable, elle était divisée en 4 zones. 

* Bobines. Lecture/écriture: 00001 à 09999
* Entrées discrètes. lecture seule: 10001 à 19999
* Registres d'entrées. Lecture seule: 30001 à 39999
* Registres de maintien. Lecture/écriture: 40001 à 49999

Cependant, avec les avancées technologiques, la structure des mémoires de stockage a évolué et chaque fabricant peut organiser la mémoire interne comme il l'entend. Il doit donc fournir une table d'adresses à utiliser pour chaque équipement.
Les données :
Les données numériques sont toujours transmises sous forme d'entiers. Le fabricant fournit le format numérique afin de convertir la donnée brute en donnée exploitable. Par exemple, il communiquera le nombre de décimales (e.g gain=0.1). Il faudra alors faire la conversion lors de la réception de la valeur sur le maître.
Remarque :
Dans le tableau ci-dessus, vous remarquerez que l’esclave détermine le début et la fin d’une trame grâce à deux silences. Ces silences doivent chacun avoir une durée équivalente à celle de la transmission de 3,5 caractères (1 caractère = 11 bits).
Avec une vitesse de transmission de 9600 bauds, le silence doit donc durer 3,5 * 11 * (1/9600) secondes, soit environ 4 millisecondes.
C’est pourquoi, lors de la programmation de l’IPX800, il faut éviter de traiter plus de deux requêtes dans une même règle. De même, il est préférable de ne pas lier plus de deux requêtes à une même ressource ou événement. Par défaut, l’IPX800 insère des silences de 5 ms permettant d’écouter le bus et peut stocker jusqu’à deux trames sans problème. Cependant, si vous surchargez la règle avec plus de deux requêtes, l’IPX pourrait envoyer les trames trop rapprochées les unes des autres, ce qui risquerait de provoquer une perte d’informations. Il devient alors judicieux d’ajouter des objets “Délais” entre les émissions de trames afin de permettre l’écoute du bus et le traitement des réponses.

les différents codes de fonction

Il y a 19 fonctions en tout, voici les principales prises en charge par l'ipx800 V5

Requêtes de lecture.

Les requêtes de lecture sont facilement mises en œuvre sur l'IPX800 grâce à l'objet "Modbus Read". Cet objet permet la sélection de l'une des 4 fonctions détaillées ci-dessous.

Lecture des bits de sortie (coils) 0x01 :

La fonction 01 en Modbus RTU est utilisée pour lire l’état des bobines (coils) d’un dispositif esclave. Les bobines sont des éléments binaires qui peuvent être soit activés (1) soit désactivés (0). Cette fonction permet au maître Modbus de vérifier l’état de ces bobines pour des opérations de contrôle et de surveillance.

Détails de la Fonction 1

  • Code de Fonction: 01 (0x01 en hexadécimal)
  • Description: Lecture de l’état des bobines
  • Utilisation: Permet au maître de lire l’état de plusieurs bobines dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse 1ere bobine Nombre de bobines à lire CRC
1 octet 01 2 octets 2 octets 2 octets

Exemple de Trame de Requête

Supposons que nous voulons lire l’état de 10 bobines à partir de l’adresse 0x0013 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x01
  • Adresse de la première bobine: 0x0013
  • Nombre de bobines: 0x000A

La trame de requête serait :

01 01 00 13 00 0A

Structure de la Trame de Réponse.

Adresse de l'esclave code fonction Nombre d'octets à suivre Valeurs des bobines lues CRC
1 octet 01 1 octet n octets 2 octets

Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, si les 10 bobines ont les états suivants : 11001101 01, la trame de réponse serait :

01 01 02 CD 01

CD représente les 8 premières bobines (11001101 en binaire) et 01 les 2 dernières (01 en binaire).

Ces trames montrent comment la fonction 1 est utilisée pour lire l’état des bobines dans un appareil esclave en Modbus RTU


Mise en œuvre sur IPX

Pour cet exemple, nous devons lire l'état de 10 bobines, c'est à dire 10 bits consécutifs. Nous pouvons utiliser des tuiles de type IO que nous pourrons nommer et utiliser individuellement dans notre système domotique.

L'adresse de début est 19 en décimal (13 en hexa).

Modbus read rtu 01.png

Lecture des entrées discrètes :0x02

Description : Lire l’état des entrées discrètes (discrete inputs) des esclaves.

La fonction 02 en Modbus RTU est utilisée pour lire l’état des entrées discrètes (input status) d’un dispositif esclave. Les entrées discrètes sont des éléments binaires similaires aux bobines, mais elles sont généralement utilisées pour lire des états de capteurs ou d’autres dispositifs d’entrée.

Détails de la Fonction 2

  • Code de Fonction: 02 (0x02 en hexadécimal)
  • Description: Lecture de l’état des entrées discrètes
  • Utilisation: Permet au maître de lire l’état de plusieurs entrées discrètes dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse 1ere entrée Nombre d'entrées à lire CRC
1 octet 02 2 octets 2 octets 2 octets


Exemple de Trame de Requête

Supposons que nous voulons lire l’état de 10 entrées discrètes à partir de l’adresse 0x0013 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x02
  • Adresse de la première entrée: 0x0013
  • Nombre d’entrées: 0x000A

La trame de requête serait :

01 02 00 13 00 0A

Structure de la Trame de Réponse

Adresse de l'esclave code fonction Nombre d'octets à suivre Valeurs des entrées lues CRC
1 octet 02 1 octet n octets 2 octets


Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, si les 10 entrées discrètes ont les états suivants : 11001101 01, la trame de réponse serait :

01 02 02 CD 01

CD représente les 8 premières entrées (11001101 en binaire) et 01 les 2 dernières (01 en binaire).

Mise en œuvre sur IPX800

Modbus Read RTU 02.png

Lecture des registres de maintien : 0x03

La fonction 03 en Modbus RTU est utilisée pour lire les registres de maintien (holding registers) d’un dispositif esclave. Les registres de maintien sont des emplacements de mémoire utilisés pour stocker des données telles que des paramètres de configuration ou des valeurs de processus.

Détails de la Fonction 3

  • Code de Fonction: 03 (0x03 en hexadécimal)
  • Description: Lecture des registres de maintien
  • Utilisation: Permet au maître de lire les valeurs de plusieurs registres de maintien dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse 1er registre Nombre de registres à lire CRC
1 octet 03 2 octets 2 octets 2 octet

Exemple de Trame de Requête

Supposons que nous voulons lire les valeurs de 3 registres à partir de l’adresse 0x0001 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x03
  • Adresse du premier registre: 0x0001
  • Nombre de registres: 0x0003

La trame de requête serait :

01 03 00 01 00 03

Structure de la Trame de Réponse

Adresse de l'esclave code fonction Nombre d'octets valeurs des registres lus CRC
1 octet 03 1 octet n octets 2 octets

Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, si les valeurs des 3 registres sont 0x000A, 0x000B, et 0x000C, la trame de réponse serait :

01 03 06 00 0A 00 0B 00 0C

06 représente le nombre d’octets de données (3 registres x 2 octets chacun).


Mise en œuvre sur IPX800

Modbus read rtu 03.png

Lecture des registres d’entrée : 0x04

La fonction 4 en Modbus RTU, également connue sous le code 0x04, est utilisée pour lire les registres d’entrée (input registers) d’un appareil esclave. Cette fonction permet au maître de lire les valeurs de plusieurs registres d’entrée en une seule commande.

Détails de la Fonction 4

  • Code de Fonction: 04 (0x04 en hexadécimal)
  • Description: Lecture des registres d’entrée
  • Utilisation: Permet au maître de lire les valeurs de plusieurs registres d’entrée dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse 1er registre Nombre de registres à lire CRC
1 octet 04 2 octets 2 octets 2 octets

Exemple de Trame de Requête

Supposons que nous voulons lire les valeurs de 3 registres d’entrée à partir de l’adresse 0x0001 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x04
  • Adresse du premier registre: 0x0001
  • Nombre de registres: 0x0003

La trame de requête serait :

01 04 00 01 00 03

Structure de la Trame de Réponse

Adresse de l'esclave code fonction Nombre d'octets de données à suivre Valeurs de registres lues CRC
1 octet 04 1 octet n octets 2 octets

Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, si les valeurs des 3 registres sont 0x000A, 0x000B, et 0x000C, la trame de réponse serait :

01 04 06 00 0A 00 0B 00 0C

06 représente le nombre d’octets de données (3 registres x 2 octets chacun).


Mise en œuvre sur IPX800

Modbus read rtu 04.png

Requêtes d’écriture

Les requêtes d'écriture sont mises en œuvre sur l'IPX800 grâce à l'objet "Modbus Write". Cet objet permet la sélection de l'une des 4 fonctions détaillées ci-dessous.

Écriture d’un bit de sortie unique : 0x05

La fonction 5 en Modbus RTU, également connue sous le code 0x05, est utilisée pour écrire une seule bobine (single coil) dans un appareil esclave1. Cette fonction permet au maître de définir l’état (ON ou OFF) d’une bobine spécifique.

Détails de la Fonction 5

  • Code de Fonction: 05 (0x05 en hexadécimal)
  • Description: Écriture d’une seule bobine
  • Utilisation: Permet au maître de modifier l’état d’une bobine spécifique dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse de la bobine valeur à écrire CRC
1 octet 05 2 octets 2 octets 2 octets


Exemple de Trame de Requête

Supposons que nous voulons écrire la valeur ON (0xFF00) dans la bobine à l’adresse 0x0001 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x05
  • Adresse de la bobine: 0x0001
  • Valeur à écrire: 0xFF00

La trame de requête serait :

01 05 00 01 FF 00

Structure de la Trame de Réponse

Adresse de l'esclave code fonction Adresse de la bobine Valeur écrite dans la bobine CRC
1 octet 05 2 octets 2 octets 2 octets


Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, la trame de réponse serait identique :

01 05 00 01 FF 00


Mise en œuvre sur IPX800

Modbus write rtu 05.png

La première analogique 8 bits sera valorisée à 255 (FF en hexa), la seconde à 0.

Nous pouvons aussi utiliser une variable 16 bits. Dans ce cas elle serait valorisée à 65280 (FF 00 en hexa).

Écriture d’un registre de maintien unique : 0x06

La fonction 06 en Modbus RTU est utilisée pour écrire une valeur dans un registre de maintien (holding register) d’un appareil esclave. Voici quelques détails supplémentaires et des exemples de trames pour illustrer son utilisation.

Détails de la Fonction 06

  • Code de Fonction: 06
  • Description: Écriture d’un seul registre de maintien
  • Utilisation: Permet au maître de modifier la valeur d’un registre spécifique dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse du registre à écrire valeur à écrire CRC
1 octet 06 2 octets 2 octets 2 octets

Exemple de Trame de Requête

Supposons que nous voulons écrire la valeur 0x00FF dans le registre à l’adresse 0x0001 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x06
  • Adresse du registre: 0x0001
  • Valeur à écrire: 0x00FF

La trame de requête serait :

01 06 00 01 00 FF

Structure de la Trame de Réponse

Adresse de l'esclave code fonction Adresse du registre écrit Valeur écrite dans le registre CRC
1 octet 06 2 octets 2 octets 2 octets


Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, la trame de réponse serait identique :

01 06 00 01 00 FF


Mise en œuvre sur ipx800

Modbus write rtu 06.png

La 1ère variable 8 bits sera valorisée à ca0, la seconde à 255 (FF en hexa).

Nous pouvons aussi utiliser une variable 16 bits valorisée à 255.

Écriture de plusieurs bits de sortie : 0x0F

La fonction 0F en Modbus RTU est utilisée pour écrire plusieurs bobines (coils) dans un appareil esclave1. Cette fonction permet au maître de définir l’état (ON ou OFF) de plusieurs bobines en une seule commande.

Détails de la Fonction 15

  • Code de Fonction: 0F (15 en décimal)
  • Description: Écriture de plusieurs bobines
  • Utilisation: Permet au maître de modifier l’état de plusieurs bobines dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse de la 1ère bobine à écrire Nombre de bobines à écrire Nombre d'octets à suivre valeur des bobines à écrire CRC
1 octet 0F 2 octets 2 octets 1 octet n octets 2 octets

Exemple de Trame de Requête

Supposons que nous voulons écrire les valeurs 0xCD (11001101 en binaire) dans 8 bobines à partir de l’adresse 0x0013 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x0F
  • Adresse de la première bobine: 0x0013
  • Nombre de bobines: 0x0008
  • Nombre d’octets de données: 0x01
  • Valeurs des bobines: 0xCD

La trame de requête serait :

01 0F 00 13 00 08 01 CD


Structure de la Trame de Réponse

Adresse de l'esclave code fonction Adresse de la 1ère bobine écrite Nombre de bobines écrites CRC
1 octet 0F 2 octets 2 octets 2 octets


Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, la trame de réponse serait :

01 0F 00 13 00 08


Mise en œuvre sur IPX800

Modbus write rtu 0F.png

avec chaque IO valorisée à 1 ou 0.

Nous pouvons également utiliser une variable 8 bits valorisée à 205 (CD en hexa)

Écriture de plusieurs registres de maintien : 0x10

La fonction 10 en Modbus RTU, également connue sous le code 0x10, est utilisée pour écrire plusieurs registres de maintien (holding registers) dans un appareil esclave1. Cette fonction permet au maître de modifier les valeurs de plusieurs registres en une seule commande.

Détails de la Fonction 10

  • Code de Fonction: 10 (16 en décimal)
  • Description: Écriture de plusieurs registres de maintien
  • Utilisation: Permet au maître de modifier les valeurs de plusieurs registres dans l’esclave.

Structure de la Trame de Requête

Adresse de l'esclave code fonction Adresse du 1er registre à écrire Nombre de registres à écrire Nombre d'octets à suivre valeur des registres à écrire CRC
1 octet 10 2 octets 2 octets 1 octet n octets 2 octets


Exemple de Trame de Requête

Supposons que nous voulons écrire les valeurs 0x000A et 0x000B dans deux registres à partir de l’adresse 0x0010 de l’esclave avec l’adresse 0x01.

  • Adresse de l’esclave: 0x01
  • Code de fonction: 0x10
  • Adresse du premier registre: 0x0010
  • Nombre de registres: 0x0002
  • Nombre d’octets de données: 0x04
  • Valeurs des registres: 0x000A 0x000B

La trame de requête serait :

01 10 00 10 00 02 04 00 0A 00 0B

Structure de la Trame de Réponse

Adresse de l'esclave code fonction Adresse du 1er registre écrit Nombre de registres écrits CRC
1 octet 10 2 octets 2 octets 2 octets

Exemple de Trame de Réponse

Pour la trame de requête ci-dessus, la trame de réponse serait :

01 10 00 10 00 02


Mise en œuvre sur ipx800

Modbus write RTU 10.png

La première analogique est valorisée à 10 (0A en hexa), la seconde à 11 (0B en hexa)

Requêtes de diagnostic

La fonction 8 en Modbus RTU, également connue sous le code 0x08, est utilisée pour diagnostiquer et tester les appareils esclaves.

Cette fonction permet au maître d’envoyer diverses commandes de diagnostic pour vérifier l’état et les performances de l’esclave.

Elle est non prise en charge par l'IPX800.

Logiciel Modbus

Pour lire les trames sur le bus RTU, vous pouvez utiliser divers logiciels gratuits disponibles sur le Web (Modbus Doctor, Simply Modbus Master, Open ModScan, ModRSsim)

Ces logiciels vous permettront de dialoguer avec votre dispositif esclave et de comprendre son mode de communication.

Cela vous sera très utile pour programmer l’IPX800 V5 par la suite.

De plus, vous aurez besoin d’un adaptateur USB pour interfacer votre PC. Vous pouvez en trouver pour moins de 20 €.

USB rs485.png

Consultez la documentation de votre adaptateur pour son installation et son branchement. En général, seules deux bornes (A et B) seront utilisées pour la communication, tandis que la borne GND servira à mettre en commun les masses entre l’alimentation du port USB et celle de l’esclave.

Cet adaptateur crée un port série virtuel qu’il faudra configurer avec les paramètres requis par l’esclave.

voici un exemple de configuration :

  • Vitesse : 9600 ou 115200 Bauds
  • Nombre de Bits : 8
  • Bit de parité : N
  • Bit de STOP : 1

En ce qui concerne le logiciel, j'utilise Modbus Doctor.

Voilà, vous êtes prêt à communiquer en Modbus RTU entre votre PC (maître) et l'esclave.

Modbus TCP

Principe

Les trames Modbus TCP et Modbus RTU ne sont pas identiques, bien qu’elles partagent certaines similitudes en termes de structure de données.

Modbus TCP utilise la communication Ethernet et les trames Modbus sont encapsulées dans des paquets TCP/IP. Cela permet une communication plus rapide et plus flexible, avec la possibilité de gérer plusieurs connexions simultanées. Les trames TCP incluent un en-tête supplémentaire pour le protocole TCP/IP.

Mise en œuvre sur IPX800

Pour émettre ou lire des trames, nous pouvons utiliser les objets "Modbus Write" et "Modbus Read".

Nous devrons alors activer le mode de communication TCP et préciser l'adresse IP de l'esclave.

Seul le paramétrage de l'entête change, la construction des données modbus avec les tuiles est identique.

En général, le port Modbus TCP est le 502. Dans nos exemples, nous utiliserons un port personnalisé 402.


Objet Modbus Write

Image Modbus Write TCP.png


Objet Modbus Read

Image Modbus TCP Read.png

Communication avec un équipement esclave :

L'esclave destinataire est déterminé par son adresse IP. La possibilité de saisir un ID a été ajoutée afin de pouvoir communiquer avec des esclaves RTU situés derrière une passerelle TCP<->RTU. Dans ce cas, l'adresse IP à renseigner est celle de la passerelle et l'ID celui de l'esclave à interroger.


Esclave RTU derrière une passerelle TCP <->RTU

Modbus TCP -RTU.png

L'adresse IP correspond à la passerelle, l'ID au dispositif RTU à interroger.

Exemples d'utilisation

Le bus RS485 doit être réalisé avec des câbles blindés, avec blindage à la terre d'un côté.

Image bus rs485 modbus.png

Capteur de conductivité Modbus RTU

J'ai acquis un capteur de conductivité (EC) qui me permettra de mesurer et réguler le taux de nutriments dans la solution qui nourrira le jardin hydroponique. Cette installation fera sans doute l'objet d'un autre article, mais je ne rentrerai pas dans les détails ici.

La conductivité d'un liquide varie avec sa température, ce capteur mesure donc les 2 grandeurs afin de permettre le calcul du facteur de correction.

Chaque grandeur pourra alors être demandée par le maître.

Branchement sur l'adaptateur USB

Capteur EC RS485 en USB.png

Les premiers tests de communication

À partir de la documentation du produit, nous pouvons configurer les communications, exploiter les réponses sur le bus, ...

je vous épargne les pages en mandarin qui accompagnaient mon capteur. Heureusement, Google Lens permet des traductions instantanées à partir de documents au format image.

Configuration du port

Pour communiquer avec le produit, il faut d'abord configurer le port COM via le logiciel que vous aurez choisi.

Voici ce que dit la documentation :

Port de communication
Vitesse en Bauds Bit de parité Bits de données Bit d'arrêt
9600 N 8 1

Ce sont donc les paramètres de la configuration du port série virtuel créé par l'adaptateur. Ces paramètres doivent être appliqués dans le logiciel Modbus.

Voilà ce que cela donne dans Modbus Doctor :

Modbus doctor config.png

Liste des registres accessibles

La documentation doit impérativement lister les adresses et formats des données pour que vous puissiez exploiter votre appareil.

Adresse des registres
Adresse Valeur Plage Lecture/Ecriture Fonctions supportées
0x 00 00 Température en °C 0 à 80.0 Lecture seule 03
0x 00 01 Conductivité en µS/cm 0 à 4000 Lecture seule 03
0x 00 03 ID Esclave 1 à 247 Lecture/Ecriture 03/06

Ce sont donc les adresses des registres qu'il sera possible de lire ou écrire, ainsi que leur description. Comme nous l'avons vu plus haut, cette partie de documentation est indispensable pour l'interprétation des données du fabricant contenues dans les réponses du capteur.


Attention : un esclave ne peut pas avoir un ID 0.

La documentation du capteur indique que l’ID peut être 0, bien que cette valeur soit strictement réservée aux messages de diffusion (Broadcasts).

Si par erreur vous configurez votre appareil avec un ID à 0, il deviendra alors injoignable. Cette mésaventure m'est arrivée pendant mon apprentissage du logiciel Modbus Doctor. Une écriture malencontreuse de la valeur 0 dans le registre 3, et hop, matériel à la poubelle.

Autre souci dans la documentation : il est mentionné que l'ID par défaut du matériel est 0 alors qu'il est de 1.

Le matériel Made in China est donc d'un rapport qualité/prix excellent, mais il faut très souvent s'attendre à galérer un peu pour la mise en œuvre.

Format d'une requête "Lecture" de registre

La réponse émise par l'esclave lors de la réception de cette requête est également formatée, mais en partie seulement. En effet, le champ "Données" n'a pas de format imposé. Le fabricant peut alors adapter le message à son produit.

Le fabricant doit alors documenter la construction de trame adoptée, le format de chaque registre et son adresse, afin que l'utilisateur final puisse lire et convertir ces variables en grandeurs réelles.

Adresse de l'esclave code fonction Nombre d'octets Données lues CRC (bits forts) CRC (Bits faibles)
1 octet 03 1 octet N * 2 octets de données 1 octet 1 octet

Nous pouvons constater que les données du capteur sont constituées de paires d'octets, dont le nombre dépend de la requête d'interrogation reçue.

Lecture de la valeur de conductivité
  • émission de la requête du maître vers l'esclave : Selon les standards de la fonction 03, construisons la requête de type 03 à destination de l'esclave #1 pour récupérer la valeur de la conductivité avec notre logiciel. Réglez le logiciel pour un affichage en hexadécimal.
01 03 00 01 00 01 xx yy


Cette trame émise par le maître est donc construite comme suit :

01 (1 octet) : ID unique de l'esclave destinataire

03 (1 octet) : Fonction lecture de registres contigus

00 01 (2 octets) : Adresse de début de lecture, ici : 1 qui correspond bien à la conductivité

00 01 (2 octets) : Nombre de registres à lire, ici 1. Nous demandons donc seulement la valeur de la conductivité.

xx yy (2 octets) : CRC. Je remplace la valeur hexadécimale par XX dans chaque octet car le code de vérification est calculé automatiquement par le logiciel et n'est pas utile à la compréhension.

Emettons la trame avec notre logiciel Modbus;

  • Réponse de L'esclave ID 1 :
01 03 02 06 FA 3B A7

Cette réponse émise par l'esclave se décompose comme ceci:

01 (1 octet) : ID de l'esclave

03 (1 octet) : la commande reçue

02 (1 octet) : le nombre d'octets qui constituent les données incluses dans la réponse, ici il y aura 2 octets

Du coup on récupère les 2 octets suivants pour connaître la valeur de la réponse :

06 FA (2 octets) : ces 2 octets, qui constituent la valeur de conductivité, devront être interprétés conformément à la doc.

3B A7 (2 octets) : CRC


La documentation donne la formule à appliquer pour obtenir la valeur de conductivité.

Soit A la valeur contenue dans l'octet de poids fort, et B celle de l'octet de poids faible.

La formule est A* 256 + B


Nous obtenons après conversion hexadécimale vers décimal : 6*256 + 250 = 1786 µS/cm

Lecture de la température
  • émission de la requête du maître vers l'esclave :

Sur le même principe, émettons une requête de lecture du registre température.

Émettons la trame suivante pour interroger le registre à l'adresse 0 qui correspond à la température.

01 03 00 00 00 01 xx xx


01 (1 octet) : ID unique de l'esclave destinataire

03 (1 octet) : Fonction lecture de registres

00 00 (2 octets) : Adresse de début de lecture, ici : 0 qui correspond bien à la température

00 01 (2 octets) : Nombre de registres à lire, ici 1. Nous demandons donc seulement la valeur de la température


Réponse de L'esclave ID 1 :

Voici la réponse de L'esclave ID 1 :

01 03 02 00 C6 38 16

Au regard de la documentation, cette réponse émise par l'esclave se décompose comme ceci:

01 (1 octet) : ID de l'esclave

03 (1 octet) : la commande reçue

02 (1 octet) : le nombre d'octets qui constituent les données incluses dans la réponse, ici il y aura 2 octets

Du coup on récupère les 2 octets suivants pour connaître la valeur de la réponse :

00 C6 (2 octets) : ces 2 octets, qui constituent la valeur de température, devront être interprétés conformément à la doc.

38 16 (2 octets) : CRC

Si nous appliquons la formule donnée par la documentation, la température est ((0x00 * 256) + 0xC6 )/10 soit 19.8°C

Requête "Écriture" de registre

Pour rappel de format de la requête est standardisé. Voir plus haut.

  • Émission de la requête Émettons la requête suivante qui permet de modifier l'ID à 2.
FE 06 00 03 00 02 xx xx

La demande d'écriture se décompose ainsi :

FE : adresse de l'esclave. 254 correspond à un message de diffusion.

06 : Fonction Écriture

00 03 : Adresse du registre à modifier

00 02 : valeur à écrire


NB : dans cet exemple, nous modifions l'ID de l'esclave via un message de diffusion. Cela est possible uniquement parce que nous n'avons qu'un seul esclave connecté, l'ID devant être unique.

A faire :Vérifier si réponse de l'esclave. commenter ici.

Capteur EC sur IPX800 V5

Le schéma de connexion

L’IPX800 V5 propose des objets “Modbus Read” pour les requêtes de lecture et des objets “Modbus Write” pour les fonctions d’écriture sur les registres.

Ces objets peuvent être liés à des ressources ou à des événements, et il est également possible de créer des scénarios personnalisés.

Chaque valeur de registre lue peut être utilisée comme variable dans les automatismes, offrant ainsi une grande flexibilité dans la gestion de vos systèmes.

Connexion EC RTU v5.png

Configuration du mode de communication

La configuration du mode de communication série (RTU) se fait de manière centrale sur la page SYSTEM via la tuile MODBUS.

Il suffit de reporter les paramètres documentés par le fabricant du capteur.

Si vous avez plusieurs esclaves, il faudra veiller à les configurer pour utiliser la même vitesse de communication. Si vous ne pouvez pas, sachez qu'il existe des convertisseurs (Baud rate converters) qui vous permettront d'harmoniser les vitesses entre l'IPX800 (maître) et les esclaves.

Image config COM RTU.png

Création d'un objet Lecture

La création d'un objet "Modbus read" nécessite la connaissance du format de la trame RTU.

Si vous vous rappelez bien, nous avons vu que la réponse de l'esclave à une requête de Lecture comportait une séquence d'octets que le fabricant pouvait adapter à son produit. Il va donc falloir donner la structure de ces données afin que l'ipx800 puisse interpréter les réponses du capteur.

Pour ce faire, nous allons reconstituer la séquence à l'aide de tuiles IO ou analogiques que nous glissons dans la zone "Modbus Frame".

Pour notre exemple, nous souhaitons lire la température à l'adresse 0.

La réponse de l'esclave contient les données sur 2 octets comme nous avons pu le tester précédemment.

Nous pourrions récupérer ces 2 octets dans une variable 16 bits mais pour l'exemple nous allons utiliser 2 analogiques 8 bits.

Lorsque l'on dépose une tuile, il est immédiatement demandé d'associer une ressource (source de données).

Il est alors possible d'associer une variable existante ou en créer une nouvelle.


Image modbus read.png

Vous pouvez tester la requête avec le bouton envoi et vérifier si les variables analogiques récupèrent les bonnes valeurs.

L'ipx800 affiche les valeurs en décimal.

Création d'un objet Écriture

Notre capteur accepte les requêtes Écriture sur le registre en adresse 3, ce qui permet l'affectation d'un ID unique.

Créons un objet "Modbus Write" qui attribue l'ID 4.

Nous avons vu précédemment que la valeur à écrire se composait de 2 octets. Notre cas permet l'utilisation d'une variable analogique 16 bits qui pourra contenir la valeur 4 à envoyer au registre.

Glissons une tuile de type A16 et nommons la.

Vous pouvez tester la requête avec le bouton d'envoi.

Exemple d'utilisation

Notre capteur ne nécessite pas l'automatisation des requêtes d'écriture. En effet, seul le changement d'ID est possible, et celui-ci ne se fait qu'une fois en théorie, à la mise en œuvre du dispositif.

Cependant il est utile de mémoriser cette requête car au moment du remplacement du capteur en cas de panne, il suffira d'envoyer la requête pour lui réaffecter le bon ID. Si vos capteurs permettaient la modification d'autres paramètres comme la vitesse, une commande de réinitialisation, mémorisez ces requêtes qui pourront vous faire gagner du temps en cas de problème.


Nous allons donc automatiser la lecture de la température à intervalle régulier à l'aide d'un objet clignotant. Nous opterons pour une fréquence raisonnable pour ne pas saturer notre bus RTU. J'ai très peu de capteurs sur mon installation, je me décide pour un refresh toutes les 6 secondes, c'est suffisant pour suivre une température en cas de régulation.


Créons un clignotant et lions le à l'entrée "Départ" de l'objet Modbus Read. Désormais, la valeur des 2 octets correspondant à la température mesurée par le capteur remontera toutes les 3 secondes dans nos 2 variables analogiques 8 bits.

Image clignotant pour RTU.png

Il ne reste plus qu'à créer un objet fonction qui calculera la grandeur réelle via la formule communiquée par le fabricant.

Comme je l'ai écrit plus haut, j'ai utilisé volontairement 2 variables de 8 bits afin de vous montrer une utilisation avancée des objets fonctions : les variables.

Nous allons donc créer une formule utilisant les variables sous la forme $id$.



J'ai dû en fait créer 2 fonctions pour que les calculs réalisés par l'IPX800 V5 soient juste.

J'ai donc lié la variable représentant l'octet de poids fort à cette fonction

Image fonction 1 temp rtu.png

puis j'ai lié la variable représentant l'octet de poids faible à cet objet. Sa formule reprend le résultat de la fonction précédente pour l'obtention du résultat final.

Pour plus d'informations concernant l'usage des variables dans les formules, veuillez vous référer à cet article.

Image fonction 2 temp rtu.png

Le traitement de la valeur de l'octet de poids fort et de l'octet de poids faible de conductivité par les objets fonctions est bâti de la même manière.

La formule diffère un peu vu que je corrige la valeur EC selon la température. Je n'entrerai pas dans les détails ici.

Remarque : si nous avions glissé une tuile analogique 16 bits dans l'objet Modbus Read au lieu des 2 tuiles 8 bits, la formule de l'objet fonction serait plus simple et deviendrait  X/10.
Cela n'imposerait pas le découpage de la formule sur 2 fonctions.

Capteur de dioxyde de carbone

Connexion à l'IPX800

Image CO2 RTU.png

Adresses des données

Ces informations sont communiquées par le fabricant.

Registres de données
Adresse de registre

(Hex)

nom du registre Nombre d'octets Contenu Fonction supportée
0000 Humidité 2 0.1%RH Lecture
0001 Température 2 0.1°C Lecture
0002 CO2 2 1 ppm Lecture
0033 Valeur de calibration température 2 0.1 Lecture/écriture
0038 Valeur de calibration Humidité 2 0.1 Lecture/écriture
003D Valeur de calibration CO2 2 1 ppm Lecture/écriture
Registres de configuration
Adresse de registre

(Hex)

nom du registre Nombre d'octets Contenu Fonction supportée
07D0 ID esclave 2 1-254 Lecture/écriture
07D1 Baud Rate 2 0:2400

1:4800*

2:9600

Lecture/écriture
requêtes de lecture

Nous avons pu voir plus haut avec le capteur de conductivité que le format des requêtes est standardisé.

Nous appliquerons donc le même standard ici.

Exemple 1 : l'humidité

L'adresse du registre contenant la valeur du taux d'humidité est 00 00. Nous souhaitons lire 1 registre.

L'ID du capteur est 1.

Constituons la requête avec la fonction 03

01 : ID

03 : Fonction de lecture

00 00 : adresse du 1er registre à lire sur 2 octets

00 01 : nombre de registres consécutifs à lire (2 octets)

xx xx : CRC code calculé par le logiciel

01 03 00 00 00 01 xx xx

Le capteur répond avec cette trame :

01 03 02 00 D5 79 DB

01 : ID

03 : Fonction de lecture

02 : nombre d'octets constituant la réponse

00 D5 : valeur de l'humidité

79 DB : CRC

La valeur d'humidité est donc ((00 * 256) + 213)/10 = 21.3%RH

Exemple 2 : le CO2

L'adresse du registre pour le CO2 est 00 02.

01 03 00 02 00 01 xx xx

01 : ID

03 : Fonction lecture

00 02 : adresse 1er registre à lire

00 01 : nombre de registres à lire

xx xx : CRC

Le capteur envoie cette réponse

01 03 02 0B B8 BF 06

01 : ID

03 : Fonction de lecture

02 : nombre d'octets constituant la réponse

0B B8 : valeur de l'humidité

BF 06 : CRC

La quantité de CO2 est donc ((11* 256) + 184) = 3000 ppm

Exemple 3 : humidité, température et CO2 ensemble

L'adresse du premier registre à lire est 00 00

01 03 00 00 00 03 xx xx

01 : ID

03 : Fonction lecture

00 00 : adresse 1er registre à lire

00 03 : nombre de registres à lire

xx xx : CRC

Le capteur envoie cette réponse

01 03 06 01 67 FF 85 0B B8 33 DC

01 : ID

03 : Fonction lecture

06 : nombre d'octets dans les données

01 67 : valeur d'humidité. L'humidité est de 359/10=35.9 %RH

FF 85 : valeur de température. Quand elle est négative, elle remonte comme complément. Ici, la température vaut -7.5°C

0B B8 : Valeur CO2. Le CO2 est de 3000 ppm

33 BC : CRC

Requêtes d'écriture

Appliquons les standards aux requêtes d'écriture

Exemple 1 : modification de l'ID

Nous souhaitons modifier l'ID 01 en ID 02. Nous émettons une requête type 06

Trame émise

01 06 07 D0 00 02 08 86

01 : id esclave

06 : Fonction écriture d'un registre de maintien unique

07 D0 : adresse du registre à modifier

00 02 : donnée à écrire (nouvel ID)

08 86 : CRC


Réponse de l'esclave

01 06 07 D0 00 02 08 86

L'esclave réémet la même trame pour confirmer le traitement.

Exemple 2 : modification du Baud Rate

Par défaut, le capteur est configuré en 4800 Bauds. Nous souhaitons le passer en 9600 Bauds.

Trame émise

01 06 07 D1 00 02 59 46

01 : id esclave

06 : Fonction écriture d'un registre de maintien unique

07 D1 : adresse du registre à modifier

00 02 : donnée à écrire . La valeur 2 correspond à 9600 Bauds selon la documentation.

59 46 : CRC


Réponse de l'esclave

01 06 07 D1 00 02 59 46

L'esclave réémet la même trame pour confirmer le traitement.

Astuces

Le complément à 2

Au moment de la rédaction de cet article, l'IPX800 V5 ne reconnait ni ne traite les valeurs négatives envoyées par les capteurs RTU. En effet, la plupart d'entre eux émet la valeur en appliquant le complément à 2 qui est une méthode utilisée en informatique pour représenter les nombres entiers, en particulier les nombres négatifs, en binaire. Voici comment cela fonctionne :

  1. Inversion des bits : Pour trouver le complément à 2 d’un nombre binaire, commencez par inverser tous les bits du nombre (changez les 0 en 1 et les 1 en 0). Par exemple, pour le nombre binaire 0101, l’inversion des bits donne 1010.
  2. Ajout de 1 : Ensuite, ajoutez 1 au nombre inversé. En continuant avec notre exemple, 1010 devient 1011 après l’ajout de 1.

Exemple : La température est de -7.5°C, vu que la valeur est négative, le capteur doit émettre le complément à 2 de 75.

Inversion des bits : 75 en binaire sur 2 octets s'écrit est 00000000 01001011.

L'inversion des bits donne 11111111 10110100

Ajout de 1 : le résultat est de 11111111 10110101, soit FF B5 en hexadécimal.


Pour contourner ce manque, @GwenLR propose une solution construite avec un comparateur et un objet fonction.

=> Si la valeur reçue de Modbus est inférieure à 32768, elle est réputée positive. La sortie du comparateur passe ON. Sa valeur est donc 1. L'objet formule traite alors cette valeur normalement avec un gain de 0.1 pour le traitement des décimales.

La formule est en effet équivalente à X/10.

=> Si la valeur reçue de Modbus est supérieure à 32768, la sortie du comparateur passe à OFF. La valeur reçue est réputée négative car le capteur l'a transmise avec l'application du complément à 2. Pour détricoter cela, il faut alors retrancher 65536 de la valeur lue. Cette opération est faite grâce au passage à ON de l'IO (donc valorisée à 1) liée par un lien de type NOT à la sortie du comparateur. La formule de l'objet fonction devient alors équivalente à (X - 65536)/10.

Complément à 2 Modbus.png

Vous pouvez vous référer à ce post sur le forum pour plus d'information.

Interception et analyse de trames Modbus

Précédemment nous avons vu comment simuler un maître ou un esclave Modbus grâce à des logiciels gratuits comme Modbus Doctor.

Pour analyser les échanges entre l'IPX800 V5 et ses esclaves Modbus, il est également possible de connecter un PC sur le bus et d'utiliser un logiciel de capture de trames, à des fins d'analyse.

En RTU, vous devrez utiliser un adaptateur USB-RS485, en TCP/IP il suffira de mettre le PC sur le même réseau que l'IPX800.

Modbus RTU

  1. Utiliser un analyseur de protocole : Un analyseur de protocole Modbus RTU, tel que Wireshark avec un plugin Modbus, peut être utilisé pour capturer et analyser les trames. Vous aurez besoin d’un convertisseur RS-485 vers USB pour connecter le réseau Modbus à votre ordinateur.
  2. Utiliser un enregistreur de données : Un enregistreur de données Modbus peut être placé sur le réseau pour capturer les trames de communication. Ces enregistreurs peuvent stocker les données pour une analyse ultérieure.
    • Simply Modbus Slave : Ce logiciel permet de tester et de déboguer les systèmes Modbus RTU et ASCII. Il affiche également le trafic de données et ne nécessite aucune installation.
    • Modbus Poll : Bien que ce logiciel soit principalement payant, il offre une version d’essai gratuite qui peut être utile pour des besoins temporaires ou pour évaluer ses fonctionnalités.
    • QModMaster : Un logiciel open-source qui permet de tester et de déboguer les communications Modbus RTU et TCP. Il est disponible gratuitement et offre une interface utilisateur conviviale.
  3. Utiliser un logiciel de supervision : Certains logiciels de supervision et de contrôle (SCADA) offrent des fonctionnalités de capture et d’analyse des trames Modbus RTU. Vous pouvez configurer le logiciel pour enregistrer les communications entre le maître et les esclaves.
    • QModMaster : Un logiciel open-source qui permet de tester et de déboguer les communications Modbus RTU et TCP. Il est disponible gratuitement et offre une interface utilisateur conviviale1.
    • Modbus Doctor : Un utilitaire freeware permettant de se connecter aux appareils industriels communiquant en protocole Modbus RTU ou TCP. Ce logiciel permet de tester et mettre au point une liaison Modbus de manière visuelle et conviviale2.
    • Simply Modbus Slave : Ce logiciel permet de tester et de déboguer les systèmes Modbus RTU et ASCII. Il affiche également le trafic de données et ne nécessite aucune installation
  4. Utiliser un microcontrôleur : Vous pouvez programmer un microcontrôleur (comme un Arduino ou un ESP32) pour écouter les communications sur le bus Modbus et enregistrer les trames pour une analyse ultérieur Voici quelques bibliothèques pour ESP32:
    • ESP-Modbus : Une bibliothèque officielle d’Espressif pour la communication Modbus sur les réseaux basés sur RS485, WiFi et Ethernet. Elle prend en charge les implémentations maître et esclave pour les ports série et TCP1.
    • Modbus-ESP : Une bibliothèque qui permet à votre ESP8266/ESP32 de communiquer via le protocole Modbus, en agissant comme maître, esclave ou les deux. Elle prend en charge Modbus IP via réseau sans fil et Modbus RTU via ligne série2.
    • eModbus : Une bibliothèque Modbus pour les protocoles RTU, ASCII et TCP, principalement développée pour les microcontrôleurs ESP323.
  5. Utiliser un convertisseur RS-485 : Connectez un convertisseur RS-485 à votre ordinateur et utilisez un logiciel de terminal série pour capturer les trames Modbus RTU. Vous pouvez ensuite analyser les données capturées manuellement ou avec un logiciel d’analyse.

Modbus TCP

Pour intercepter et analyser des trames Modbus TCP, vous pouvez suivre ces étapes :

  1. Utiliser Wireshark : Wireshark est un outil puissant pour capturer et analyser les trames réseau, y compris Modbus TCP. Vous pouvez installer Wireshark sur votre ordinateur et configurer une capture de paquets sur l’interface réseau utilisée par le Modbus TCP. Wireshark dispose de filtres spécifiques pour Modbus qui facilitent l’analyse des trames.
  2. Utiliser un analyseur de protocole Modbus : Il existe des logiciels spécialisés pour l’analyse des trames Modbus TCP. Ces outils peuvent fournir des informations détaillées sur les communications Modbus et aider à diagnostiquer les problèmes.
  3. Configurer un port mirroring : Si vous utilisez un switch manageable, vous pouvez configurer le port mirroring pour copier le trafic réseau de l’interface Modbus TCP vers une autre interface où vous pouvez capturer les trames avec Wireshark ou un autre outil d’analyse.
  4. Utiliser un logiciel de supervision : Certains logiciels de supervision et de contrôle (SCADA) offrent des fonctionnalités de capture et d’analyse des trames Modbus TCP. Vous pouvez configurer le logiciel pour enregistrer les communications entre le maître et les esclaves.

Pour plus de détails, vous pouvez consulter des tutoriels vidéo comme celui-ci sur YouTube qui explique comment analyser les trames Modbus TCP avec Wireshark

Conclusion

Modbus est une compétence importante de l’IPX800 V5.

L’utilisation de Modbus RTU nous ouvre les portes de l’intégration d’objets intelligents et communicants dans notre domotique.

Pour ma part, je peux désormais envisager mon futur projet : un système de dosage automatique des engrais liquides dans la solution nutritive d’un mini potager hydroponique, avec régulation du taux de CO2 pour la santé des plants.

Image potager hydroponique.png

Amis débutants, j’espère que cet article vous aura permis de découvrir ou approfondir le protocole Modbus, peut-être en aurez vous besoin au sein de votre installation. Même si nous n’avons pas abordé des sujets complexes comme la gestion d’appareils technologiques sophistiqués (e.g : climatiseurs gainables) ne vous découragez pas !

Modbus étant open-source, il existe d'innombrables bibliothèques prêtes à l'emploi permettant aux non-initiés de concevoir leurs propres appareils communicants à base de SBC (ESP8266, ESP32, RPI, etc.).

Des spécialistes Modbus sont présents parmi la communauté du forum, ils seront ravis de vous guider dans les cas plus complexes. N’hésitez pas à poser vos questions et à partager vos expériences !

Annexes

Modbus Specifications