Module Lua `serial`

Le module serial permet d'interagir avec des ports série pour la communication avec des équipements industriels, capteurs ou autres périphériques.

Import

local serial = require("serial1")

Configuration YAML

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

iot:
  modules:
    serial:
      - name: serial1           # nom unique du module
        port: /dev/ttyUSB0      # port série
        baudrate: 9600          # vitesse de transmission (défaut : 9600)
        databits: 8             # bits de données (défaut : 8)
        stopbits: 1             # bits d'arrêt (défaut : 1)
        parity: N               # parité (défaut : N)
        timeout: 5              # timeout en secondes (défaut : 5)
        rs485:                  # configuration RS485 (optionnel)
          enabled: false
          delay_rts_before_send: 0
          delay_rts_after_send: 0
          rts_high_during_send: false
          rts_high_after_send: false
          rx_during_tx: false

Détails de la configuration

name (string, requis) : Nom du module. Il doit être unique et ne pas contenir d'espaces ou de caractères spéciaux.
port (string, requis) : Port série à utiliser. Format : /dev/ttyUSB0 (Linux) ou COM3 (Windows).
baudrate (integer) : Vitesse de transmission (baud rate). Par défaut 9600. Valeurs courantes : 9600, 19200, 38400, 57600, 115200.
databits (integer) : Nombre de bits de données. Par défaut 8. Valeurs possibles : 7, 8.
stopbits (integer) : Nombre de bits d'arrêt. Par défaut 1. Valeurs possibles : 1, 2.
parity (string) : Type de parité. Par défaut N. Valeurs possibles :
N : Aucune parité (None)
E : Parité paire (Even)
O : Parité impaire (Odd)
timeout (integer) : Délai d'attente pour la lecture en secondes. Par défaut 5.

Configuration RS485 (optionnel)

rs485.enabled (boolean) : Active le mode RS485. Par défaut false.
rs485.delay_rts_before_send (integer) : Délai avant activation RTS en millisecondes.
rs485.delay_rts_after_send (integer) : Délai après désactivation RTS en millisecondes.
rs485.rts_high_during_send (boolean) : RTS haut pendant l'émission.
rs485.rts_high_after_send (boolean) : RTS haut après l'émission.
rx_during_tx (boolean) : Activer la réception pendant l'émission.

API Lua

Liste des fonctions

Fonction	Signature Lua	Rôle	Retour (succès)	Retour (échec)
`connect`	`bool, err = serial.connect()`	Ouvre la connexion série.	`true, nil`	`nil, "msg"`
`disconnect`	`bool, err = serial.disconnect()`	Ferme la connexion série.	`true, nil`	`nil, "msg"`
`writestring`	`bool, err = serial.writestring(message)`	Écrit une chaîne de caractères.	`true, nil`	`nil, "msg"`
`write`	`bool, err = serial.write(byteTable)`	Écrit une séquence de bytes.	`true, nil`	`nil, "msg"`
`readstring`	`data, err = serial.readstring(length)`	Lit une chaîne de caractères.	`string, nil`	`nil, "msg"`
`read`	`tbl, err = serial.read(length)`	Lit une séquence de bytes.	`table, nil`	`nil, "msg"`
Champs	`serial.name`, `serial.type`	Métadonnées du module.	–	–

`serial.connect()`

Établit une connexion avec le port série configuré.

Paramètres : Aucun.
Retour :
En cas de succès : true, nil.
En cas d'échec : nil, message d'erreur.

local serial = require("serial1")

local ok, err = serial.connect()
if not ok then
    print("Erreur lors de la connexion au port série : " .. err)
else
    print("Connexion réussie au port série.")
end

`serial.disconnect()`

Ferme la connexion avec le port série.

Paramètres : Aucun.
Retour :
En cas de succès : true, nil.
En cas d'échec : nil, message d'erreur.

local serial = require("serial1")

local ok, err = serial.disconnect()
if ok then
    print("Déconnexion réussie du port série.")
end

`serial.writestring(message)`

Écrit une chaîne de caractères dans le port série.

Paramètres :
message (string) : Le message à écrire dans le port série.
Retour :
En cas de succès : true, nil.
En cas d'échec : nil, message d'erreur.

local serial = require("serial1")

local ok, err = serial.writestring("Hello, Serial Port!")
if not ok then
    print("Erreur lors de l'écriture : " .. err)
else
    print("Message écrit avec succès.")
end

`serial.write(byteTable)`

Écrit une séquence de bytes dans le port série.

Paramètres :
byteTable (table) : Un tableau Lua contenant des entiers représentant les bytes à écrire.
Retour :
En cas de succès : true, nil.
En cas d'échec : nil, message d'erreur.

local serial = require("serial1")

local byteTable = {0x01, 0x02, 0x03, 0x04}
local ok, err = serial.write(byteTable)
if not ok then
    print("Erreur lors de l'écriture : " .. err)
else
    print("Bytes écrits avec succès.")
end

`serial.readstring(length)`

Lit une chaîne de caractères depuis le port série.

Paramètres :
length (integer) : Le nombre de caractères à lire depuis le port série.
Retour :
En cas de succès : la chaîne de caractères lue, nil.
En cas d'échec : nil, message d'erreur.

local serial = require("serial1")

local message, err = serial.readstring(10)
if not message then
    print("Erreur lors de la lecture : " .. err)
else
    print("Message lu : " .. message)
end

`serial.read(length)`

Lit une séquence de bytes depuis le port série.

Paramètres :
length (integer) : Le nombre de bytes à lire depuis le port série.
Retour :
En cas de succès : tableau Lua contenant les bytes lus, nil.
En cas d'échec : nil, message d'erreur.

local serial = require("serial1")

local byteTable, err = serial.read(10)
if not byteTable then
    print("Erreur lors de la lecture : " .. err)
else
    print("Bytes lus :")
    for i, byte in ipairs(byteTable) do
        print(string.format("  [%d] = 0x%02X", i, byte))
    end
end

Exemple complet

local serial = require("serial1")

-- Connexion au port série
local ok, err = serial.connect()
if not ok then
    print("Erreur de connexion : " .. err)
    return
end

-- Envoi d'une commande
serial.writestring("AT\r\n")

-- Lecture de la réponse
local response, err = serial.readstring(100)
if response then
    print("Réponse : " .. response)
end

-- Déconnexion
serial.disconnect()

Champs Lua associés

serial.name : Retourne le nom de l'instance du module.
serial.type : Retourne le type du module ("serial").

Module Lua serial