Bonjour a tous,
Je cherche a comprendre la logique de fonctionnement de l’objet modbus dans la V5.
Je souhaite envoyer a un péripherique une succession de codes (octets).
D’après mes recherches, La trame envoyée est une succession d’octets en hexa.
La trame commence par l’adresse du péripherique, suivi de la fonction, puis les données et pour finir le CRC (controle d’erreur sur 2 octets).
Dans mon cas présent (le tout en hexa):
Adresse: 01
Fonction: 06
Données: 00 01 03 00
CRC : D8 FA
Ma question est : comment introduire cette trame dans l’objet Modbus Write ?
Il y a le champ ID péripherique. Cela sous entend que l’adresse (dans mon cas 01) ne fera pas partie de la trame a configurer?
Pour le mode, je ne saisis pas la différence entre écriture bits et ecriture registre,
Pour l’adresse de début, je suppose que cela peut avoir son intérêt en cas d’ecriture d’un seul bit (ou registre) et définir quel octet sera ecrit ?
Dans la trame, je suppose qu’il faut utiliser des ana16 ou 32 et stocker dans ces ana la valeur décimale convertie de l’hexa pour reformer la trame? J’ai compris qu’il est possible de glisser des tuiles IO judiscieusement disposées pour modifier qu’un bit dans la trame, mais pour l’instant, je souhaite simplement envoyer la trame décrite précédemment.
Un peu d’aide serait bienvenue.
Merci aux docteurs de la V5 …
Bonsoir @jeff850 ,
Votre compréhension est bonne, reste plus que des petites subtilités (que je découvre aussi 
)
La fonction 06: correspond en modbus à l’Ecriture d’un registre
La partie données se décompose alors en 2, ds ce cas de figure:
0001: qui correspond à l’adresse du registre
0300: la valeur à écrire
L’écriture d’un registre doit se faire sur 2 octets en commençant à l’adresse 1
Pour coder cette partie, vous avez 2 choix…
0300 (HEX) = 768(DEC) = 1100000000 (BIN)
- soit vous codez 1100000000 sur 16 IO…
- soit vous déclarez une ANA16 ayant la valeur 768 (de type RAW)
Le CRC est assuré par la V5
Pour répondre à votre question une solution pourrait être:
Merci pour votre retour 
Je ne peux pas tester… (je n’ai pas d’appareil modbus)
Un grand merci @Jweb !! 
Je confirme, les informations sont bien exactes !! cela fonctionne.
Donc en résumé, Si l’on prends en compte la trame a envoyer au périphérique, au final, la config de l’objet MODBUS ecriture décompose en grande partie la trame.
Avec adresse de l’esclave : Champ ID du périphérique
Fonction (06) inhérente puisque qu’on est en modbus « écriture » (donc 06)
1ere partie des données (adresse registre) : Champ Adresse de début
Ne reste que la valeur à écrire à composer en ANA (converti dec) ou IO (converti bin).
(CRC géré par l’IPX.)
J’ai fait quelques manips, cela réagit bien. d’ailleurs, lorsque la trame est fausse, après avoir cliqué sur envoi, un message orange apparait signalant délai d’attente dépassé, en cas de succès, message vert Trame envoyée.
Je souhaiterais juste encore comprendre la différence entre les différents modes:
Là, je suis en écriture registre seul . ce que je comprends, c’est qu’on ecris uniquement un seul registre, en l’occurence la valeur (puisque l’adresse du registre est dans l’ « adresse de début ») à savoir 0300 (hex) ou 768 (dec) dans mon exemple. c’est bien exact?
Il y a possibilité d’écriture bit seul , plusieurs bits et plusieurs registres . Ce qui va changer c’est la manière de composer la trame ?
Une fois passé le test de compréhension modbus ecriture, je vais me lancer dans le modbus lecture.
Encore merci @Jweb , les infos et explications sont cohérentes et claires malgré que vous n’avez pas de module modbus pour tester ! Je cherche a bien comprendre le fonctionnement plutot de me contenter d’utiliser la solution proposée.
Bonjour @jeff850
Merci pr vos retours 
Non pas tout à fait… c’est vous qui m’avez donné l’instruction… 6 correspond a l’écriture d’un registre
Par ex 16 correspond à l’écriture de plusieurs registres
Cela doit être décrit ds la doc de votre appareil.
De même en lecture il y a plusieurs codes pour des types de lectures différentes
Oui c’est ca. Il faut analyser la chose à écrire
- L’adresse du périphérique esclave
- Le type de traitement à réaliser avec le code fonction
- Trier la partie data en fonction de la fonction
Ds votre cas l’adresse du registre est ds la partie data (le 1er octet).
Ce qui va changer:
- Le code Fonction
- La partie data
N’hésitez pas à continuer de poster vos retours cela inspirera certainement d’autres personnes
OK, donc en fonction du mode choisi, la trame sera composée avec le code correspondant
Soit (si j’ai bien compris) :
-Ecriture registre seul : 06
-Ecriture plusieurs registres : 16
-Ecriture bit seul : 05
-Ecriture plusieurs bits : 15
A utiliser selon le mode de fonctionnement compatible avec le périphérique.
En passe a la lecture MODBUS
Par analogie, si j’ai bien tout compris:
Champ ID du périphérique : Adresse de l’esclave
Mode :
-Lecture bit d’entrée : code 02
-Lecture bit de sortie : code 01
-Lecture registre d’entrée : code 04
-Lecture registre de sortie : code 03
A choisir selon la commande a utiliser pour le périphérique.
Champ Adresse de début : Adresse du registre a interroger (même principe que l’écriture registre)
Puis la trame a composer selon la réponse du périphérique.
Dans mon cas, réponse sur 2 octets mais la valeur prends uniquement 0 ou 1 . J’ai donc placé une ANA8 pour le 1er octet (qui restera toujours a 0) , puis une tuile IO qui est sur le bit de poids faible et qui représente le bit qui changera de valeur (0 ou 1).
Il est possible d’y placer une ANA16 (2 octets), c’est a utiliser selon le type d’information en retour. Pour une entrée binaire, il sera plus judicieux d’utiliser une (ou des ) IO , pour des entrées analogiques, plutot des ANA.
Ce qui nous donne ceci :
Un petit clic sur envoi et l’apparition du message « IHM trame envoyée » nous confirme que la trame est correcte, puis un petit controle de l’état de la IO me confirme bien un retour d’état cohérent.
Bonjour @jeff850 ,
Les principales fonctions en modbus sont généralement:
1 : Lecture de bits (coils)
2 : Lecture de bits d’entrée (discret inputs)
3 : Lecture de mots (holding registers)
4 : Lecture de mots d’entrée (input registers)
5 : Ecriture de 1 bit
6 : Ecriture de 1 mot
15 : Ecriture de n bits
16 : Ecriture de n mots