Module `modbus`

Le module modbus permet d'interagir avec des appareils Modbus via différents modes de transmission (TCP, RTU). Il expose plusieurs fonctions pour lire/écrire des registres et gérer la connexion Modbus.

Pour l'importer il faut utiliser la déclaration suivante :

local modbus = require("modbus1") 
-- remplacer modbus1 par le name dans le fichier de configuration

Configuration

Le module modbus nécessite une configuration spécifique pour fonctionner. Cette configuration est définie dans le fichier de configuration de l'agent.

Pour la configuration voici un exemple de toutes les options possibles :

iot:
  modules:
    modbus: # module modbus
      - name: modbus1 # nom du module
        transmissionmode: RTU # mode de transmission (auto, TCP, RTUoverTCP, ASCIIoverTCP, RTU, ASCII, file)
        controller: file:///dev/ttyUSB0 # contrôleur (file, tcp)
        baudrate: 9600 # baudrate
        databits: 8 # databits
        parity: N # parity (N, E, O)
        stopbits: 1 # stopbits
        slaveid: 1 # slaveid
        timeout: 5 # timeout en secondes
        debug: false # permet d'activer le mode debug
        rs485: # configuration rs485 
          enabled: false # activer rs485
          delay_rts_before_send: 2 # délai avant l'envoi
          delay_rts_after_send: 2 # délai après l'envoi
          rts_high_during_send: false # rts haut pendant l'envoi
          rts_high_after_send: false # rts haut après l'envoi
          rx_during_tx: false # rx pendant tx
      - name: modbus2 # nom du module
        transmissionmode: TCP # mode de transmission
        controller: tcp://127.0.0.1:502 # contrôleur
        slaveid: 1 # slaveid

Détails de la configuration

name : Nom du module. Il doit être unique et ne pas contenir d'espaces ou de caractères spéciaux.
transmissionmode : Mode de transmission. Il peut s'agir de auto, TCP, RTUoverTCP, ASCIIoverTCP, RTU, ASCII, ou file.
controller : Contrôleur. Il peut s'agir d'un fichier (ex. /dev/ttyUSB0, file:///dev/ttyUSB0) ou d'une adresse TCP (ex. tcp://127.0.0.1:502).
baudrate : Baudrate pour la communication série (ex. 9600).
databits : Nombre de bits de données (ex. 8).
parity : Parité pour la communication série. Il peut s'agir de N (aucune), E (pair), ou O (impair).
stopbits : Nombre de bits d'arrêt (ex. 1).
slaveid : ID de l'esclave Modbus (ex. 1).
timeout : Délai d'attente pour les opérations Modbus, en secondes (ex. 5).
debug : Permet d'activer le mode debug pour le module Modbus (ex. false).
rs485 : Configuration pour le mode RS485.
enabled : Activer le mode RS485 (ex. false).
delay_rts_before_send : Délai avant l'envoi, en millisecondes (ex. 2).
delay_rts_after_send : Délai après l'envoi, en millisecondes (ex. 2).
rts_high_during_send : RTS haut pendant l'envoi (ex. false).
rts_high_after_send : RTS haut après l'envoi (ex. false).
rx_during_tx : RX pendant TX (ex. false).

Fonctions Lua

`modbus.connect()`

Établit une connexion avec l'appareil Modbus.

Paramètres : Aucun
Retour :
true si la connexion est réussie.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local modbus = require("modbus1")

local status, err = modbus.connect()
if not status then
    print("Erreur lors de la connexion Modbus : " .. err)
    return
end

`modbus.disconnect()`

Ferme la connexion avec l'appareil Modbus.

Paramètres : Aucun
Retour :
true si la déconnexion est réussie.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local status, err = modbus.disconnect()

if not status then
    print("Erreur lors de la déconnexion Modbus : " .. err)
    return
end

`modbus.readCoils(address, byteorder[, resultType])`

Lit les coils depuis l'appareil Modbus à l'adresse spécifiée.

Paramètres :
address (int) : L'adresse à partir de laquelle commencer la lecture.
byteorder (string) : L'ordre des octets.
resultType (string, optionnel) : Le type de résultat attendu (par défaut int16).
Retour :
Un tableau Lua contenant les résultats ou nil suivi d'un message d'erreur en cas d'échec.

local modbus = require("modbus1")

local address = 0 -- adresse de départ
local byteorder = "big" -- ordre des octets
local resultType = "int16" -- type de résultat (optionnel)

local coils, err = modbus.readCoils(address, byteorder, resultType)
if not coils then
    print("Erreur lors de la lecture des coils : " .. err)
else
    for i, v in ipairs(coils) do
        print("Coil " .. (address + i - 1) .. ": " .. v)
    end
end

`modbus.writeSingleCoil(address, value)`

Écrit une valeur unique dans un coil à l'adresse spécifiée.

Paramètres :
address (int) : L'adresse du coil à écrire.
value (bool) : La valeur à écrire (true ou false).
Retour :
true si l'écriture est réussie.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local modbus = require("modbus1")

local address = 0 -- adresse du coil
local value = true -- valeur à écrire

local status, err = modbus.writeSingleCoil(address, value)
if not status then
    print("Erreur lors de l'écriture du coil : " .. err)
else
    print("Coil " .. address .. " écrit avec succès.")
end

`modbus.writeMultipleCoils(address, values)`

Écrit plusieurs valeurs dans des coils à l'adresse spécifiée.

Paramètres :
address (int) : L'adresse à partir de laquelle commencer l'écriture.
values (string) : Une chaîne représentant les valeurs ('1' ou '0').
Retour :
true si l'écriture est réussie.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local modbus = require("modbus1")

local address = 0 -- adresse de départ
local values = "1100" -- valeurs à écrire (ex. '1100')

local status, err = modbus.writeMultipleCoils(address, values)
if not status then
    print("Erreur lors de l'écriture des coils : " .. err)
else
    print("Coils écrits avec succès à partir de l'adresse " .. address .. ".")
end

`modbus.readDiscreteInputs(address, byteorder[, resultType])`

Lit les entrées discrètes depuis l'appareil Modbus à l'adresse spécifiée.

Paramètres :
address (int) : L'adresse à partir de laquelle commencer la lecture.
byteorder (string) : L'ordre des octets.
resultType (string, optionnel) : Le type de résultat attendu (par défaut int16).
Retour :
Un tableau Lua contenant les résultats ou nil suivi d'un message d'erreur en cas d'échec.

local modbus = require("modbus1")

local address = 0 -- adresse de départ
local byteorder = "big" -- ordre des octets
local resultType = "int16" -- type de résultat (optionnel)

local inputs, err = modbus.readDiscreteInputs(address, byteorder, resultType)
if not inputs then
    print("Erreur lors de la lecture des entrées discrètes : " .. err)
else
    for i, v in ipairs(inputs) do
        print("Input " .. (address + i - 1) .. ": " .. v)
    end
end

`modbus.readHoldingRegisters(address, byteorder[, resultType, quantity])`

Lit les registres de maintien (holding registers) depuis l'appareil Modbus.

Paramètres :
address (int) : L'adresse du premier registre à lire.
byteorder (string) : L'ordre des octets.
resultType (string, optionnel) : Le type de résultat attendu (par défaut int16).
quantity (int, optionnel) : Le nombre de registres à lire (défaut : déterminé par resultType).
Retour :
Un tableau Lua contenant les résultats ou nil suivi d'un message d'erreur en cas d'échec.

local modbus = require("modbus1")

local address = 0 -- adresse de départ
local byteorder = "big" -- ordre des octets
local resultType = "int16" -- type de résultat (optionnel)
local quantity = 10 -- nombre de registres à lire (optionnel)

local registers, err = modbus.readHoldingRegisters(address, byteorder, resultType, quantity)
if not registers then
    print("Erreur lors de la lecture des registres de maintien : " .. err)
else
    for i, v in ipairs(registers) do
        print("Register " .. (address + i - 1) .. ": " .. v)
    end
end

`modbus.writeSingleRegister(address, value)`

Écrit une valeur unique dans un registre à l'adresse spécifiée.

Paramètres :
address (int) : L'adresse du registre à écrire.
value (int) : La valeur à écrire.
Retour :
true si l'écriture est réussie.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local modbus = require("modbus1")

local address = 0 -- adresse du registre
local value = 12345 -- valeur à écrire

local status, err = modbus.writeSingleRegister(address, value)
if not status then
    print("Erreur lors de l'écriture du registre : " .. err)
else
    print("Register " .. address .. " écrit avec succès.")
end

`modbus.writeMultipleRegisters(address, byteorder, quantity, value[, valueType])`

Écrit plusieurs registres dans l'appareil Modbus.

Paramètres :
address (int) : L'adresse à partir de laquelle commencer l'écriture.
byteorder (string) : L'ordre des octets.
quantity (int) : Le nombre de registres à écrire.
value (variable) : La valeur à écrire.
valueType (string, optionnel) : Le type de la valeur (défaut : int16).
Retour :
true si l'écriture est réussie.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local modbus = require("modbus1")

local address = 0 -- adresse de départ
local byteorder = "big" -- ordre des octets
local quantity = 2 -- nombre de registres à écrire
local value = 12345 -- valeur à écrire
local valueType = "int16" -- type de valeur (optionnel)

local status, err = modbus.writeMultipleRegisters(address, byteorder, quantity, value, valueType)
if not status then
    print("Erreur lors de l'écriture des registres : " .. err)
else
    print("Registres écrits avec succès à partir de l'adresse " .. address .. ".")
end

`modbus.readInputRegisters(address, byteorder[, resultType, quantity])`

Lit les registres d'entrée (input registers) depuis l'appareil Modbus.

Paramètres :
address (int) : L'adresse du premier registre à lire.
byteorder (string) : L'ordre des octets.
resultType (string, optionnel) : Le type de résultat attendu (par défaut int16).
quantity (int, optionnel) : Le nombre de registres à lire (défaut : déterminé par resultType).
Retour :
Un tableau Lua contenant les résultats ou nil suivi d'un message d'erreur en cas d'échec.

local modbus = require("modbus1")

local address = 0 -- adresse de départ
local byteorder = "big" -- ordre des octets
local resultType = "int16" -- type de résultat (optionnel)
local quantity = 10 -- nombre de registres à lire (optionnel)

local registers, err = modbus.readInputRegisters(address, byteorder, resultType, quantity)
if not registers then
    print("Erreur lors de la lecture des registres d'entrée : " .. err)
else
    for i, v in ipairs(registers) do
        print("Input Register " .. (address + i - 1) .. ": " .. v)
    end
end

`modbus.setSlaveId(slaveId)`

Change l'ID de l'esclave pour la connexion Modbus.

Paramètres :
slaveId (int) : Le nouvel ID de l'esclave.
Retour :
true si l'ID de l'esclave est défini avec succès.
En cas d'échec, retourne nil suivi d'un message d'erreur.

local modbus = require("modbus1")

local newSlaveId = 2 -- nouvel ID de l'esclave

local status, err = modbus.setSlaveId(newSlaveId)
if not status then
    print("Erreur lors de la définition de l'ID de l'esclave : " .. err)
else
    print("ID de l'esclave défini avec succès à " .. newSlaveId .. ".")
end

Champs Lua associés

modbus.name : Retourne le nom de l'instance Modbus.
modbus.type : Retourne le type du module (ici, modbus1).

Module modbus

Configuration

Détails de la configuration

Fonctions Lua

modbus.connect()

modbus.disconnect()

modbus.readCoils(address, byteorder[, resultType])

modbus.writeSingleCoil(address, value)

modbus.writeMultipleCoils(address, values)

modbus.readDiscreteInputs(address, byteorder[, resultType])

modbus.readHoldingRegisters(address, byteorder[, resultType, quantity])

modbus.writeSingleRegister(address, value)

modbus.writeMultipleRegisters(address, byteorder, quantity, value[, valueType])

modbus.readInputRegisters(address, byteorder[, resultType, quantity])

modbus.setSlaveId(slaveId)