Forum KNX francophone / English KNX forum

Version complète : passerelle VMC modbus / KNX
Vous consultez actuellement la version basse qualité d’un document. Voir la version complète avec le bon formatage.
Pages : 1 2 3 4
Bonjour à tous !

J'ai mis en place chez moi une VMC communicante en modbus : la unelvent DOMEO 210.

Le but ultime est donc de pouvoir la contrôler via KNX.

Je vois donc ça en 2 etapes :
  • la controler en modbus
  • faire la passerelle vers knx

J'ai vu qu'il existe des passerelles toute faite modbus/knx mais c'est hors de prix (en tout cas, hors de mon budget)
Dans l'idée, je me voyais bien partir sur un raspberry et faire le pont avec la partie KNX via le trio.

fma38, vu ton poste sur ta VMC, je pense que tu as des billes sur le sujet. De mon côté, j'ai eu de la doc par unelvent qui décrit les paramètres modbus mis en place. je ne sais juste pas comment les attaquer ...
et premier point, est ce qu'il y a du matériel particulier à acheter ou on peut tout faire directement sur le raspberry ?

merci d'avance pour toutes les infos intéressantes !!

Vincent
Déjà, côté hard, il te faut une passerelle USB / RS485, genre :

http://www.ebay.fr/itm/Adaptador-USB-a-R...1545922484
http://www.ebay.fr/itm/KMTronic-USB-auf-...1397225004

(le second me semble plus sérieux ; il utilise un chip FTDI, ultra connu et qui fonctionne bien. En plus, le premier n'a visiblement pas la masse, donc prudence, la VMC peut ne pas aimer).

Après, c'est juste du code. Si tu es sous RPi, tu pourras tester avec python, et par la suite utiliser pKNyX pour faire office de passerelle KNX.

Je t'enverrai un bout de code quand tu auras la passerelle physique RS485, mais il manque quand même des infos pour communiquer : il faudrait savoir de quels types de registres il s'agit, pour chaque groupe. Modbus connaît 4 types :

* Discrete Output Coils (1 bit, RW)
* Discrete Input Contacts (1 bit, RO)
* Analog Input Registers (16 bits, RO)
* Analog Output Holding Registers (16 bits, RW)

Cf http://www.simplymodbus.ca/FAQ.htm#Stored

(Tu noteras que c'est à la base fait pour les automates. Mais on en fait bien ce qu'on veux)

D'après ta doc, j'aurais tendance à dire que le premier groupe correspond aux Discrete Input Contacts, le second aux Discrete Output Coils, et le dernier aux Analog Input Registers. Mais bon, c'est à vue de nez ! Il va falloir leur demander plus de précisions. Et être sûr que le numéro de la première colonne correspond bien à l'adresse de registre Modbus...

J'espère que c'est clair, jusque là Wink
Ah, et j'oubliais : il faut aussi connaître l'ID de la VMC (numéro d'esclave)...
Merci beaucoup !!

Ça m'oriente bien dans mes recherches !

Je vais commencer par me procurer la passerelle puis je vais renvoyer quelques mails Wink
Bonsoir,

Ca y est, tout est en place : le raspberry, la passerelle (celle que tu m'as recommandé) et c'est branché sur la vmc.

Le support m'a envoyé quelques infos supplémentaires :

« Pouvez-vous également me confirmer que le numéro de la première colonne correspond bien à l'adresse de registre Modbus ? : oui »
« Et dernière chose, je souhaiterai également connaître l'ID de la VMC (son numéro d'esclave) ? ou savoir comment le retrouver ? : Par défaut Nº1 mais peut être modifié dans le groupe "Holding registers" nº0 (Nœud ligne Modbus). »
Ainsi que la piece jointe avec les dernieres infos ...

Aurais tu le bout de code proposé ? car là, j'avoue sécher completement sans meme savoir si je reçois la moindre info Sad

Merci d'avance !!

Vincent
Impec, y'a toutes les infos nécessaires.

Commence bien par mettre le strap JP1 pour activer le Modbus.

J'essaye de te poster un bout de code dans la journée.
Alors, il faut commencer par installer la librairie pymodbus. Sous debian :

$ sudo apt-get install python-pymodbus

Ensuite, voici quelques exemples. Leplus simple est d'utiliser le shell ipython, qui est vraiment super pratique.

Code :
from pymodbus.client.sync import ModbusTcpClient

client = ModbusTcpClient(host=<ip_de_ta_vmc>, port=502)

# lecture paramètres VERSION (descrete input)
result = client.read_coils(address=1, count=1)
print result.bits[0]

# lecture puis modification paramètre BATTERIE PRE-CHAUFFAGE (coils)
result = client.read_coils(address=1, count=1)
print result.bits[0]
client.write_coil(adresse=1, value=1)

# lecture VERSION LOGICIEL UNITE CENTRALE (input registers)
result = client.read_input_registers(address=1, count=1)
print result.registers[0]

# lecture puis modification SELECTION DEPHASAGE DEBIT (holding registers)
result = client.read_holding_registers(address=1, count=1)
print result.registers[0]
client.write_register(address=1, value=5)

client.close()

Il y a une ou deux autres méthodes à la classe ModbusTcpClient, pour lire/écrire plusieurs registres à la fois. Pour les connaître, dans ipython, tu fais (une fois la variable client créée) :

Code :
In [5]: client.<TAB>    <<<<<<<<<< ici, ça veut dire cliquer sur la touche TAB ; ipython te montrera toutes les méthodes dispos
client.close                   client.port                    client.readwrite_registers     client.write_register
client.connect                 client.read_coils              client.socket                  client.write_registers
client.execute                 client.read_discrete_inputs    client.transaction            
client.framer                  client.read_holding_registers  client.write_coil              
client.host                    client.read_input_registers    client.write_coils            

In [5]: client.write_coils?
Type:        instancemethod
String form: <bound method ModbusTcpClient.write_coils of <pymodbus.client.sync.ModbusTcpClient object at 0x7f11326d0c10>>
File:        /usr/lib/python2.7/dist-packages/pymodbus/client/common.py
Definition:  client.write_coils(self, address, values, **kwargs)
Docstring:
:param address: The starting address to write to
:param values: The values to write to the specified address
:param unit: The slave unit this request is targeting
:returns: A deferred response handle

In [6]:

Pour savoir un peu ce que les fonctions retournent, tu fais de même avec la variable result. Tu peux aussi le faire sur les fonctions d'écriture, pour voir ce que ça retourne (je n'ai pas de machine sur laquelle envoyer des commandes sous la main).

Voili. Après, tout dépendra de ce que tu veux faire. Commence par faire mumuse, et on verra ensuite si tu veux intégrer ça dans pKNyX pour mapper certains paramètres sur le bus
Merci Frédéric

je vais tester tout ça dans la journée mais je sais déjà que tu me fais gagner un temps précieux de plusieurs jours !

J'ai bien fermé le pont jp1; Ca désactive du coup la commande manuelle .. soit.

Ca tombe bien, je suis sous debian, je me lance de suite Smile

Vincent
Juste en lisant les bouts de code que tu m'as envoyé, je me pose une question sur la premiere ligne :

client = ModbusTcpClient(host=<ip_de_ta_vmc>, port=502)

Ayant la passerelle FTDI (monté sur ttyUSB0), je ne suis pas en IP entre le raspberry et la VMC.

Je vais regardé du côté de python-pymodbus comment communiquer au travers de la passerelle.
Ah, c'est con que ça désactive la commande manu... Faudrait éventuellement prévoir un petit switch, qui te permettrait de reprendre la main localement si besoin (et prévoir dans le code la perte de connexion).

Au passage, je suis me suis gaufré : le client utilisé (ModbusTcpClient) est pour une connexion Tcp ; je regarde pour le client série... Mais je pense que ça ne change rien pour le reste.
Alors voici ce qu'il faut utiliser :

Code :
from pymodbus.client.sync import ModbusSerialClient

client = ModbusSerialClient(method='ascii', port='/dev/ttyS0', baudrate=19200)
client.connect()  <<<<<< je ne sais pas trop si c'est nécessaire

Mettre le bon port (ça va être un ttyUSBxxx, je pense), et voir si c'est bien 'ascii' (sinon, essayer 'binary' ou 'rtu').
Bonjour,

Je suis dans le même projet que VF62, avec la même VMC...
Malheureusement, je n'ai pas encore eu le temps de m'y mettre. C'est loonnnng les travaux de rénovation !!!
Enfin bref, je relisais ce post, je me posais une question; le modbus desactive la télécommande ... ok.
Mais comment tu fais pour régler le debit de la VMC? Je ne vois aucune commande dans le PDF pour lui indiquer une valeur de fonctionnement...
Bonjour,

Il y a bien des commandes pour agir sur le débit qui sont ouvert en écriture, "consigne de débit" par exemple.

Jj'arrive maintenant à lire les informations en utilisant ces paramètres :

ID de la VMC : 1
Baud rate : 19200
Parité : Par (even)
Mode : RTU
8 bits de datas
1 bit de stop

Par contre, j'avoue que niveau écriture et donc modification de la consigne, je n'ai pas encore réussi à le faire ... vous êtes deux personnes à avoir relancer ce sujet cette semaine, ça m'encourage à m'y remettre !
il ne doit pas manquer grand chose.

A bientôt

Vincent
Tu utilises quoi, pour dialoguer, du coup ?
J'avais pas vu que tu avais mis un deuxième PDF avec d'autre commande R/W...
Perso, je ne communique pas encore avec la VMC, je fais encore bien trop de poussière pour la mettre en prod'...
(30/11/2014, 16:58:15)fma38 a écrit : [ -> ]Tu utilises quoi, pour dialoguer, du coup ?

Pour l'instant, j'utilise minimalmodbus avec un script python de ce style :

Code :
#!/usr/bin/env python
import minimalmodbus
import serial
instrument = minimalmodbus.Instrument('/dev/ttyUSB0', 1) # port name, slave address (in decimal)
#instrument.debug = True
instrument.serial.baudrate = 19200   # Baud
instrument.serial.bytesize = 8
instrument.serial.parity = serial.PARITY_EVEN
instrument.serial.stopbits = 1

# input registers
# temp Tint
Tint = instrument.read_register(21,1,4)
print 'Temperature interieure = ' + str(Tint)

#holding registers
Deb = instrument.read_register(10,0,3)
print 'Debit = ' + str(Deb)
#consigne
Consigne = instrument.read_register(15,1)
print 'Consigne = ' + str(Consigne)
print 'changement de consigne a 1'
instrument.write_register(15,1,0)
Consigne = instrument.read_register(15,1)
print 'Consigne = ' + str(Consigne)

Ça fonctionne pour la partie "read" mais le "write" ne modifie rien. La vmc ne modifie pas son débit (à l'oreille), et la lecture après l'écriture confirme que la consigne n'a pas été modifiée;

Je n'écris peut être pas au bon endroit. Il faudrait que je recontacte le support pour avoir leur avis.
Je ne connaissais pas cette API, mais elle est un peu bizarre... Pour le write, essaye plutôt avec la fonction 6, au lieu de 15 par défaut.

D'autre part, dis-moi exactement quels registres de quelles banques tu veux lire/modifier, car je ne pige pas bien ce que tu veux faire.
Hello,

Comme cette API te parait bizarre, je suis reparti sur pymodbus comme toi.

Mon but est assez simple, je souhaite lire le debit actuel et ensuite modifier la consigne de la vmc en mode boost pour obtenir un debit de 210 m3.

Mais j'ai un probleme pour lire le debit (que j'arrive à lire avec minimalmodbus).
J'utilise ce script :
Code :
#!/usr/bin/env python

from pymodbus.client.sync import ModbusSerialClient
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.DEBUG)

client = ModbusSerialClient(method='rtu', port='/dev/ttyUSB0', baudrate=19200, bytesize=8, stopbits=1, parity='E')
client.connect()

# lecture parametres debit (holding registers)
result = client.read_holding_registers(address=10, count=1)
print 'Deb = '
print result.bits[0]

mais j'obitens l'erreur :
Code :
DEBUG:pymodbus.transaction:Running transaction 1
DEBUG:pymodbus.transaction:recv: 0x0 0x3 0x2 0x0 0x78 0x85 0xa6
DEBUG:pymodbus.factory:Factory Response[3]
DEBUG:pymodbus.transaction:adding transaction 0
DEBUG:pymodbus.transaction:getting transaction 1
Deb =
Traceback (most recent call last):
  File "./test_pimodbus.py", line 15, in <module>
    print result.bits[0]
AttributeError: 'ReadHoldingRegistersResponse' object has no attribute 'bits'

J'ai réinstallé à peu près tout mais pas moyen
Pour info, j'ai fait l'install avec ces commandes :
Code :
git clone git://github.com/bashwork/pymodbus.git
cd pymodbus
python setup.py install

j'ai relancé le script avec l'API minimalmodbus qui semble toujours fonctionner sauf que je n'arrive pas à modifier la consigne Sad

Fin bref, venant du monde microsoft, j'ai vraiment du mal à appréhender le monde llinux Confused
L'objet retourné par read_holding_registers() est de type ReadHoldingRegistersResponse, qui a comme attributs registers, et non bits (ça, c'est le cas de l'objet retourné par read_coils(), de type ReadCoilsResponse).

Le résultat final est donc dans :

Code :
print result.registers[0]
Merci Fred,

J'ai honte, la réponse était dans le message d'erreur Confused

Merci de ton aide, je retrouve bien ma valeur de 120 m3.

Allez, étape suivante, je tente de modifier la consigne !


Cool Smile
rha ..

autant pour la lecture, les fonctions sont bien différenciées selon ce que l'on veut lire, on a donc bien : read_coils, read_discrete_inputs, read_holding_registers et read_input_registers. Ce que j'arrive bien à comprendre car ça correspond aux différentes sections de la doc pdf de la VMC.

Par contre, pour écrire, on ne retrouve que write_register(s) ou write_coil(s). sniff ...

Pourquoi faire simple quand on peut faire compliqué :/

Je vais chercher des exemples avec mon ami google ...

Ben, que veux-tu de plus ? Seuls les coils et les holdings registers sont accessibles en écriture, dans le protocole Modbus... C'est donc normal que tu aies 4 fonctions pour les lires 4 banques, mais que 2 pour écrire dans les 2 seules banques en RW...
Bonjour,

Merci pour votre discussion qui m'a été d'une grande aide.

J'aimerai faire la passerelle inversé, c'est à dire dialoguer en knx et renvoyer en modbus rtu. Le raspberry sera esclave.

C'est possible?

Merci d'avance
Ben, dans tout ce qui précède, on fait bien dans les 2 directions : on lit/écrit les registres de la vmc via l'interface modbus.

Après, il faut lire/écrire sur le bus KNX. Là, soit tu utilises linknx, soit mon framework python, pKNyX. Si tu pars sur cette dernière solition, tu n'as en fait qu'à écrire un device, et utiliser la librairie modbus pour lire/écrire les registres de la VMC.

Et vu que c'est ce que je compte faire depuis un moment avec ma Helios, si tu patientes un peu, je peux commencer à écrire ça, pour que tu vois comment ça s'articule. La première phase sera de renvoyer les 4 températures de la VMC sur le bus KNX, et de piloter le mode auto/manu plus la vitesse en manu ; tu auras donc les 2 directions.
J'ai trouvé, j'utilisai minimalmodbus qui n'a pas la possibilité d'être modbus RTU slave.

Apparement pymodbus a la fonction server, qui si j'ai bien compris, permet d'utilser le RPI comme esclave sur le protocole modbus.

Sur le modbus RTU il n'y a qu'un maitre, pour vous c'est le RPI, pour moi c'est mon automate.
La communication est toujours initiée par le maitre et l'esclave répond. L'esclave ne fait que répondre au maitre. La communication n'est pas réellement dans les 2 sens.
Pour imager ca, imagine un général et un soldat, c'est toujours le général qui fait des demandes et le soldat répond. Pas l'inverse.

Je vais patienter que tu fasses un bout de programme avec pKNyX. Je l'ai déjà installé sur mon RPI Wink

Merci pour ta réponse.

Ok, je n'avais pas compris que ton "rpi esclave" c'était vis-à-vis de modbus...

Par contre, je n'ai jamais joué avec modbus en esclave... Est-ce que tu pourrais déjà faire quelques tests de ton côté, et me montrer un bout de code de ce que tu veux faire comme dialogue avec ton automate ? Car moi, je suis maître vis-à-vis du modbus, dans ce que je veux faire... Le mode esclave semble un peu plus tricky, et je n'ai pas trop de temps pour m'y plonger...
En fait, je suis plus sûr que ce soit faisable avec pymodbus. J'ai regardé en travers leur site sans trouver d'exemple.
En tout cas, si je dois controler un slave, j'utiliserai minimalmodbus. C'est bien moins compliqué.

Sinon il me reste modbus-tk ( http://www.apidev.fr/logiciel-modbus )
Je vais jeter un oeil.
Pages : 1 2 3 4